src/agent/common/dm-status/oma_dm_status_db.c

   1 /*
   2  * oma-dm-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /*lib*/
  19 #include <unistd.h>
  20
  21 /*sync-agent*/
  22 #include <sync_agent.h>
  23
  24 /*dm-agent*/
  25 #include "common/dm-status/oma_dm_status_db.h"
  26 #include "common/dm_common.h"
  27
  28 #ifndef OMADM_AGENT_LOG
  29 #undef LOG_TAG
  30 #define LOG_TAG "OMA_DM_DB"
  31 #endif
  32
  33 /* static function define */
  34 static int _busy_handler(void *pData, int count);
  35 static DM_ERROR _query_exec(DB_HANDLER * db_handler, char *query, char *errMsg);
  36 static db_stmt __query_prepare(DB_HANDLER * db_handler, char *query, int size);
  37 static DM_ERROR __stmt_bind_text(DB_HANDLER * db_handler, db_stmt stmt, int index, const char *value);
  38 static DM_ERROR _stmt_bind_int(DB_HANDLER * db_handler, db_stmt stmt, int index, const int value);
  39 static DM_ERROR ___stmt_bind_null(DB_HANDLER * db_handler, db_stmt stmt, int index);
  40 static DM_ERROR __stmt_step(DB_HANDLER * db_handler, db_stmt stmt);
  41 /*static DM_ERROR                               __stmt_reset(DB_HANDLER *db_handler, db_stmt stmt);*/
  42 static DM_ERROR __stmt_finalize(DB_HANDLER * db_handler, db_stmt stmt);
  43 static char *_stmt_column_text(db_stmt stmt, int index);
  44 static int __stmt_column_int(db_stmt stmt, int index);
  45 static DM_ERROR _get_table(DB_HANDLER * db_handler, char *query, char ***result, int *row_count, int *col_count);
  46 static void __free_table(char **result);
  47
  48 static int _exist_table(DB_HANDLER * db_handler, const char *table_name);
  49 static int _get_data_count(DB_HANDLER * db_handler, char *query, int size);
  50 static char *_replace_engine_status_value(ENGINE_STATUS_VALUE engine_status_value);
  51
  52 static char *__create_table[] = {
  53         /* 1. create engine_status_tbl */
  54         "create table engine_status_tbl "
  55             "( "
  56             "engine_id integer, "
  57             "engine_status integer default null, "
  58             "server_id varchar(100) default null, "
  59             "server_url varchar(100) default null, "
  60             "correlator varchar(100) default null, "
  61             "mo_path varchar(200) default null, "
  62             "result_status integer not null, "
  63             "ui_mode varchar(100) default null, " "task_id integer not null, " "ui_noti_type integer, " "download_click integer, " "update_time integer not null, " "constraint engine_status_tbl_pk primary key(engine_id)" ");",
  64 };
  65
  66 static char *__delete_table[] = {
  67         /* 1. delete engine_status_tbl */
  68         "delete from engine_status_tbl",
  69
  70 };
  71
  72 DM_ERROR dm_open_agent(DB_HANDLER ** db_handler)
  73 {
  74         _EXTERN_FUNC_ENTER;
  75
  76         int ret = 0;
  77         char *errMsg = 0;
  78
  79         if (*db_handler == NULL) {
  80                 ret = sqlite3_open("/opt/dbspace/.dm_service.db", db_handler);
  81                 if (ret != SQLITE_OK)
  82                         goto FINISH;
  83
  84                 /* register busy handler */
  85                 ret = sqlite3_busy_handler(*db_handler, _busy_handler, 0);
  86                 if (ret != SQLITE_OK) {
  87                         _DEBUG_INFO("fail to register busy handler", errMsg);
  88                         goto FINISH;
  89                 }
  90
  91                 /* enable persist journal mode */
  92                 ret = sqlite3_exec(*db_handler, "PRAGMA journal_mode = PERSIST", 0, 0, &errMsg);
  93                 if (ret != SQLITE_OK) {
  94                         _DEBUG_INFO("fail to change journal mode: %s", errMsg);
  95                         goto FINISH;
  96                 }
  97                 _DEBUG_INFO("db_open success");
  98         } else {
  99                 _DEBUG_INFO("db_already opened");
 100         }
 101
 102         _EXTERN_FUNC_EXIT;
 103         return DM_OK;
 104
 105  FINISH:
 106
 107         _DEBUG_INFO("db_open failed(%d) : %s", ret, sqlite3_errmsg(*db_handler));
 108
 109         if (errMsg != NULL)
 110                 sqlite3_free(errMsg);
 111
 112         sqlite3_close(*db_handler);
 113         *db_handler = 0;
 114
 115         _EXTERN_FUNC_EXIT;
 116         return DM_ERR_UNKNOWN;
 117 }
 118
 119 DM_ERROR dm_close_agent(DB_HANDLER * db_handler)
 120 {
 121         _EXTERN_FUNC_ENTER;
 122
 123         int ret = 0;
 124         ret = sqlite3_close(db_handler);
 125         db_handler = 0;
 126
 127         if (ret != SQLITE_OK) {
 128                 _DEBUG_INFO("db_close failed(%d) : %s", ret, sqlite3_errmsg(db_handler));
 129                 _EXTERN_FUNC_EXIT;
 130                 return DM_ERR_UNKNOWN;
 131         }
 132
 133         _DEBUG_INFO("db_close success");
 134
 135         _EXTERN_FUNC_EXIT;
 136
 137         return DM_OK;
 138 }
 139
 140 DM_ERROR dm_create_table(DB_HANDLER * db_handler)
 141 {
 142         _EXTERN_FUNC_ENTER;
 143
 144         DM_ERROR ret = DM_OK;
 145
 146         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 147
 148         if ((dm_begin_transaction(db_handler) != DM_OK)) {
 149                 _DEBUG_INFO("mo_db_default_tbl_create failed");
 150                 _EXTERN_FUNC_EXIT;
 151                 return DM_ERR_UNKNOWN;
 152         }
 153
 154         /* 1. create engine_status_tbl */
 155         if (_exist_table(db_handler, "engine_status_tbl") == 0) {
 156                 ret = _query_exec(db_handler, __create_table[0], "engine_status_tbl_create failed");
 157                 if (ret != DM_OK)
 158                         goto FINISH;
 159         }
 160
 161         /* add normal engine */
 162         if (dm_isExist_engine_id(db_handler, 0) == 0) {
 163                 engine_status status;
 164                 memset(&status, 0x00, sizeof(engine_status));
 165                 status.engine_id = 0;
 166                 status.engine_status = 1;
 167                 status.result_status = 0;
 168                 status.task_id = 0;
 169                 status.ui_noti_type = 0;
 170                 status.download_click = 0;
 171                 ret = dm_add_engine_status(db_handler, &status);
 172                 _DEBUG_INFO("create dm service tbl : %d", ret);
 173         }
 174
 175  FINISH:
 176
 177         if (ret != DM_OK) {
 178                 dm_end_transaction(db_handler, TRANSACTION_ROLLBACK_);
 179                 ret = DM_ERR_UNKNOWN;
 180         } else {
 181                 ret = dm_end_transaction(db_handler, TRANSACTION_COMMIT_);
 182         }
 183
 184         _EXTERN_FUNC_EXIT;
 185         return ret;
 186 }
 187
 188 DM_ERROR dm_delete_table(DB_HANDLER * db_handler)
 189 {
 190         _EXTERN_FUNC_ENTER;
 191
 192         DM_ERROR ret = DM_OK;
 193         int i = 0;
 194         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 195
 196         if ((dm_begin_transaction(db_handler) != DM_OK)) {
 197                 _DEBUG_INFO("default_tbl_delete failed");
 198                 _EXTERN_FUNC_EXIT;
 199                 return DM_ERR_UNKNOWN;
 200         }
 201
 202         /* delete all default table */
 203         for (i = 0; i < DB_TABLE_NAME_MAX; i++) {
 204                 ret = _query_exec(db_handler, __delete_table[i], "default_tbl_delete failed");
 205                 if (ret != DM_OK)
 206                         goto FINISH;
 207         }
 208
 209  FINISH:
 210
 211         if (ret != DM_OK) {
 212                 dm_end_transaction(db_handler, TRANSACTION_ROLLBACK_);
 213                 ret = DM_ERR_UNKNOWN;
 214         } else {
 215                 ret = dm_end_transaction(db_handler, TRANSACTION_COMMIT_);
 216                 _DEBUG_INFO("end transaction : %d", ret);
 217         }
 218
 219         _EXTERN_FUNC_EXIT;
 220         return ret;
 221 }
 222
 223 DM_ERROR dm_reset_table(DB_HANDLER * db_handler)
 224 {
 225         _EXTERN_FUNC_ENTER;
 226
 227         DM_ERROR ret = DM_OK;
 228
 229         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 230
 231         if ((dm_begin_transaction(db_handler) != DM_OK)) {
 232                 _DEBUG_INFO("default_tbl_delete failed");
 233                 _EXTERN_FUNC_EXIT;
 234                 return DM_ERR_UNKNOWN;
 235         }
 236
 237         /*ret = dm_delete_table(db_handler);
 238            if (ret != DM_OK)
 239            goto FINISH; */
 240
 241         /* delete all default table */
 242         int i = 0;
 243         for (i = 0; i < DB_TABLE_NAME_MAX; i++) {
 244                 ret = _query_exec(db_handler, __delete_table[i], "default_tbl_delete failed");
 245                 if (ret != DM_OK)
 246                         goto FINISH;
 247         }
 248
 249         ret = dm_init_engine_status(db_handler);
 250         if (ret != DM_OK)
 251                 goto FINISH;
 252
 253  FINISH:
 254
 255         if (ret != DM_OK) {
 256                 dm_end_transaction(db_handler, TRANSACTION_ROLLBACK_);
 257                 ret = DM_ERR_UNKNOWN;
 258         } else {
 259                 ret = dm_end_transaction(db_handler, TRANSACTION_COMMIT_);
 260                 _DEBUG_INFO("end transaction : %d", ret);
 261         }
 262
 263         _EXTERN_FUNC_EXIT;
 264         return ret;
 265 }
 266
 267 DM_ERROR dm_begin_transaction(DB_HANDLER * db_handler)
 268 {
 269         _EXTERN_FUNC_ENTER;
 270
 271         DM_ERROR ret = _query_exec(db_handler, "begin immediate", "begin_transaction failed");
 272         _DEBUG_INFO("begin transaction : %d", ret);
 273 /*      if (ret == SYNC_AGENT_DA_ERR_QUERY_FAILED)
 274                 ret = SYNC_AGENT_DA_ERR_TRANSACTION_FAILED;*/
 275
 276         _EXTERN_FUNC_EXIT;
 277         return ret;
 278 }
 279
 280 DM_ERROR dm_end_transaction(DB_HANDLER * db_handler, DB_TRANSACTION transaction)
 281 {
 282         _EXTERN_FUNC_ENTER;
 283
 284         DM_ERROR ret = DM_OK;
 285         char *query = 0;
 286         char *errMsg = 0;
 287
 288         if (transaction == TRANSACTION_COMMIT_) {
 289                 query = "commit transaction";
 290                 errMsg = "commit_transaction failed";
 291         } else if (transaction == TRANSACTION_ROLLBACK_) {
 292                 query = "rollback transaction";
 293                 errMsg = "rollback_transaction failed";
 294         }
 295
 296         ret = _query_exec(db_handler, query, errMsg);
 297         if (ret == DM_ERR_UNKNOWN) {
 298                 if (transaction == TRANSACTION_COMMIT_) {
 299                         query = "rollback transaction";
 300                         errMsg = "rollback_transaction failed";
 301                         ret = _query_exec(db_handler, query, errMsg);
 302                         if (ret == DM_OK)
 303                                 _DEBUG_INFO("rollback_transaction success");
 304                 }
 305                 ret = DM_ERR_UNKNOWN;
 306                 _DEBUG_INFO("end transaction error : %d", ret);
 307         }
 308
 309         _EXTERN_FUNC_EXIT;
 310         return ret;
 311 }
 312
 313 DM_ERROR dm_init_engine_status(DB_HANDLER * db_handler)
 314 {
 315         _EXTERN_FUNC_ENTER;
 316
 317         DM_ERROR ret = DM_ERR_UNKNOWN;
 318
 319         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 320
 321         /* add normal engine */
 322         if (dm_isExist_engine_id(db_handler, 0) == 0) {
 323                 engine_status status;
 324                 memset(&status, 0x00, sizeof(engine_status));
 325                 status.engine_id = 0;
 326                 status.engine_status = 1;
 327                 status.result_status = 0;
 328                 status.task_id = 0;
 329                 status.ui_noti_type = 0;
 330                 status.download_click = 0;
 331                 ret = dm_add_engine_status(db_handler, &status);
 332                 _DEBUG_INFO("dm add engine status : %d", ret);
 333         }
 334
 335         _EXTERN_FUNC_EXIT;
 336         return ret;
 337 }
 338
 339 DM_ERROR dm_add_engine_status(DB_HANDLER * db_handler, engine_status * status)
 340 {
 341         _EXTERN_FUNC_ENTER;
 342
 343         DM_ERROR ret = DM_OK;
 344         db_stmt stmt = 0;
 345
 346         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 347         retvm_if(status == NULL, DM_ERR_UNKNOWN, "db status is NULL !!");
 348
 349         char *query = "insert into engine_status_tbl (engine_id, engine_status, server_id, server_url, correlator, mo_path, result_status, ui_mode, task_id, ui_noti_type, download_click, update_time) " "values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
 350
 351         stmt = __query_prepare(db_handler, query, strlen(query));
 352         if (stmt == NULL) {
 353                 ret = DM_ERR_UNKNOWN;
 354                 _DEBUG_INFO("ERROR DB");
 355                 goto FINISH;
 356         }
 357
 358         _stmt_bind_int(db_handler, stmt, 1, status->engine_id);
 359         _stmt_bind_int(db_handler, stmt, 2, status->engine_status);
 360         __stmt_bind_text(db_handler, stmt, 3, status->server_id);
 361         __stmt_bind_text(db_handler, stmt, 4, status->server_url);
 362         __stmt_bind_text(db_handler, stmt, 5, status->correlator);
 363         __stmt_bind_text(db_handler, stmt, 6, status->mo_path);
 364         _stmt_bind_int(db_handler, stmt, 7, status->result_status);
 365         __stmt_bind_text(db_handler, stmt, 8, status->ui_mode);
 366         _stmt_bind_int(db_handler, stmt, 9, status->task_id);
 367         _stmt_bind_int(db_handler, stmt, 10, status->ui_noti_type);
 368         _stmt_bind_int(db_handler, stmt, 11, status->download_click);
 369         _stmt_bind_int(db_handler, stmt, 12, (int)(time(&status->update_time)));
 370
 371         ret = __stmt_step(db_handler, stmt);
 372         if (ret != DM_OK)
 373                 ret = DM_ERR_UNKNOWN;
 374
 375  FINISH:
 376
 377         if (stmt != NULL)
 378                 __stmt_finalize(db_handler, stmt);
 379
 380         _EXTERN_FUNC_EXIT;
 381         return ret;
 382 }
 383
 384 DM_ERROR dm_delete_engine_status(DB_HANDLER * db_handler, int engine_id)
 385 {
 386         _EXTERN_FUNC_ENTER;
 387
 388         DM_ERROR ret = DM_OK;
 389         db_stmt stmt = 0;
 390
 391         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 392
 393         char *query = "delete from engine_status_tbl where engine_id = ?";
 394
 395         stmt = __query_prepare(db_handler, query, strlen(query));
 396         if (stmt == NULL) {
 397                 ret = DM_ERR_UNKNOWN;
 398                 goto FINISH;
 399         }
 400
 401         _stmt_bind_int(db_handler, stmt, 1, engine_id);
 402         ret = __stmt_step(db_handler, stmt);
 403
 404  FINISH:
 405
 406         if (stmt != NULL)
 407                 __stmt_finalize(db_handler, stmt);
 408
 409         _EXTERN_FUNC_EXIT;
 410         return ret;
 411 }
 412
 413 DM_ERROR dm_update_engine_status(DB_HANDLER * db_handler, engine_status * status)
 414 {
 415         _EXTERN_FUNC_ENTER;
 416
 417         DM_ERROR ret = DM_OK;
 418         db_stmt stmt = 0;
 419
 420         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 421         retvm_if(status == NULL, DM_ERR_UNKNOWN, "db status is NULL !!");
 422
 423         char *query = "update engine_status_tbl "
 424             "set engine_status = ?, server_id = ?, server_url = ?, correlator = ?, mo_path = ?, result_status = ?, ui_mode = ?,  task_id = ?,  ui_noti_type = ?, download_click = ?, update_time = ? " "where engine_id = ?";
 425
 426         stmt = __query_prepare(db_handler, query, strlen(query));
 427         if (stmt == NULL) {
 428                 ret = DM_ERR_UNKNOWN;
 429                 goto FINISH;
 430         }
 431
 432         _stmt_bind_int(db_handler, stmt, 1, status->engine_status);
 433         __stmt_bind_text(db_handler, stmt, 2, status->server_id);
 434         __stmt_bind_text(db_handler, stmt, 3, status->server_url);
 435         __stmt_bind_text(db_handler, stmt, 4, status->correlator);
 436         __stmt_bind_text(db_handler, stmt, 5, status->mo_path);
 437         _stmt_bind_int(db_handler, stmt, 6, status->result_status);
 438         __stmt_bind_text(db_handler, stmt, 7, status->ui_mode);
 439         _stmt_bind_int(db_handler, stmt, 8, status->task_id);
 440         _stmt_bind_int(db_handler, stmt, 9, status->ui_noti_type);
 441         _stmt_bind_int(db_handler, stmt, 10, status->download_click);
 442         _stmt_bind_int(db_handler, stmt, 11, (int)(time(&status->update_time)));
 443         _stmt_bind_int(db_handler, stmt, 12, status->engine_id);
 444
 445         ret = __stmt_step(db_handler, stmt);
 446         if (ret != DM_OK)
 447                 ret = DM_ERR_UNKNOWN;
 448
 449  FINISH:
 450
 451         if (stmt != NULL)
 452                 __stmt_finalize(db_handler, stmt);
 453
 454         _EXTERN_FUNC_EXIT;
 455         return ret;
 456 }
 457
 458 DM_ERROR dm_update_engine_status_column(DB_HANDLER * db_handler, int engine_id, ENGINE_STATUS_VALUE engine_status_value, void *value)
 459 {
 460         _EXTERN_FUNC_ENTER;
 461
 462         DM_ERROR ret = DM_OK;
 463         db_stmt stmt = 0;
 464         char query[MAX_QUERY_LENGTH] = { 0, };
 465         char *column_name = _replace_engine_status_value(engine_status_value);
 466         time_t update_time;
 467
 468         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 469
 470         snprintf(query, sizeof(query), "update engine_status_tbl set %s = ?, update_time= %d where engine_id = %d", column_name, (int)(time(&update_time)), engine_id);
 471
 472         stmt = __query_prepare(db_handler, query, strlen(query));
 473         if (stmt == NULL) {
 474                 ret = DM_ERR_UNKNOWN;
 475                 goto FINISH;
 476         }
 477
 478         if (engine_status_value == VALUE_ENGINE_STATUS || engine_status_value == VALUE_RESULT_STATUS || engine_status_value == VALUE_TASK_ID || engine_status_value == VALUE_UI_NOTI_TYPE || engine_status_value == VALUE_DOWNLOAD_CLICK) {
 479                 int *engine_status = (int *)value;
 480                 _stmt_bind_int(db_handler, stmt, 1, *engine_status);
 481         } else {
 482                 char *str = (char *)value;
 483                 __stmt_bind_text(db_handler, stmt, 1, str);
 484         }
 485
 486         ret = __stmt_step(db_handler, stmt);
 487         if (ret != DM_OK)
 488                 ret = DM_ERR_UNKNOWN;
 489
 490  FINISH:
 491
 492         if (stmt != NULL)
 493                 __stmt_finalize(db_handler, stmt);
 494
 495         _EXTERN_FUNC_EXIT;
 496         return ret;
 497 }
 498
 499 DM_ERROR dm_get_engine_status(DB_HANDLER * db_handler, int engine_id, engine_status ** status)
 500 {
 501         _EXTERN_FUNC_ENTER;
 502
 503         DM_ERROR ret = DM_OK;
 504         db_stmt stmt = 0;
 505         char *query = "select * from engine_status_tbl where engine_id = ?";
 506         engine_status *temp_status = 0;
 507
 508         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 509
 510         stmt = __query_prepare(db_handler, query, strlen(query));
 511         if (stmt != NULL) {
 512                 _stmt_bind_int(db_handler, stmt, 1, engine_id);
 513
 514                 if (__stmt_step(db_handler, stmt) == DM_ERR_MORE_DATA) {
 515                         temp_status = (engine_status *) calloc(1, sizeof(engine_status));
 516                         if (temp_status == NULL) {
 517                                 _DEBUG_INFO("alloc fail");
 518                                 _EXTERN_FUNC_EXIT;
 519                                 return COMMON_ERR_ALLOC;
 520                         }
 521                         temp_status->engine_id = __stmt_column_int(stmt, 0);
 522                         temp_status->engine_status = __stmt_column_int(stmt, 1);
 523                         temp_status->server_id = _stmt_column_text(stmt, 2);
 524                         temp_status->server_url = _stmt_column_text(stmt, 3);
 525                         temp_status->correlator = _stmt_column_text(stmt, 4);
 526                         temp_status->mo_path = _stmt_column_text(stmt, 5);
 527                         temp_status->result_status = __stmt_column_int(stmt, 6);
 528                         temp_status->ui_mode = _stmt_column_text(stmt, 7);
 529                         temp_status->task_id = __stmt_column_int(stmt, 8);
 530                         temp_status->ui_noti_type = __stmt_column_int(stmt, 9);
 531                         temp_status->download_click = __stmt_column_int(stmt, 10);
 532                         temp_status->update_time = __stmt_column_int(stmt, 11);
 533                 }
 534                 ret = __stmt_finalize(db_handler, stmt);
 535         } else {
 536                 _EXTERN_FUNC_EXIT;
 537                 return DM_ERR_UNKNOWN;
 538         }
 539
 540         (*status) = temp_status;
 541
 542         _EXTERN_FUNC_EXIT;
 543         return ret;
 544 }
 545
 546 DM_ERROR dm_get_aII_engine_status(DB_HANDLER * db_handler, engine_status ** status_list, int *count)
 547 {
 548         _EXTERN_FUNC_ENTER;
 549
 550         DM_ERROR ret = DM_OK;
 551         engine_status *temp_status = 0;
 552         char **result = 0;
 553         int row_count = 0;
 554         int col_count = 0;
 555         int index = 6;
 556         int i = 0;
 557         char query[MAX_QUERY_LENGTH] = { 0, };
 558
 559         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 560
 561         snprintf(query, sizeof(query), "select * from engine_status_tbl");
 562
 563         ret = _get_table(db_handler, query, &result, &row_count, &col_count);
 564         if ((ret == DM_OK) && (row_count != 0) && (result != NULL)) {
 565                 *count = row_count;
 566                 temp_status = (engine_status *) calloc(row_count, sizeof(engine_status));
 567                 if (temp_status == NULL) {
 568                         _DEBUG_INFO("memory_allocation failed");
 569                         ret = COMMON_ERR_ALLOC;
 570                         goto FINISH;
 571                 }
 572
 573                 for (i = 0; i < row_count; i++) {
 574                         temp_status[i].engine_id = ATOI(result[index]);
 575                         index++;
 576                         temp_status[i].engine_status = ATOI(result[index]);
 577                         index++;
 578                         temp_status[i].server_id = STRDUP(result[index]);
 579                         index++;
 580                         temp_status[i].server_url = STRDUP(result[index]);
 581                         index++;
 582                         temp_status[i].correlator = STRDUP(result[index]);
 583                         index++;
 584                         temp_status[i].mo_path = STRDUP(result[index]);
 585                         index++;
 586                         temp_status[i].result_status = ATOI(result[index]);
 587                         index++;
 588                         temp_status[i].ui_mode = STRDUP(result[index]);
 589                         index++;
 590                         temp_status[i].task_id = ATOI(result[index]);
 591                         index++;
 592                         temp_status[i].ui_noti_type = ATOI(result[index]);
 593                         index++;
 594                         temp_status[i].download_click = ATOI(result[index]);
 595                         index++;
 596                         temp_status[i].update_time = ATOI(result[index]);
 597                         index++;
 598                 }
 599         }
 600
 601  FINISH:
 602
 603         if (result != NULL)
 604                 __free_table(result);
 605
 606         *status_list = temp_status;
 607
 608         _EXTERN_FUNC_EXIT;
 609         return ret;
 610 }
 611
 612 int dm_isExist_engine_id(DB_HANDLER * db_handler, int engine_id)
 613 {
 614         _EXTERN_FUNC_ENTER;
 615
 616         int ret = 1;
 617         int dataCount = 0;
 618         char query[MAX_QUERY_LENGTH] = { 0, };
 619
 620         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 621
 622         snprintf(query, sizeof(query), "select count(*) from engine_status_tbl where engine_id = %d", engine_id);
 623
 624         dataCount = _get_data_count(db_handler, query, strlen(query));
 625
 626         if (dataCount == 0)
 627                 ret = 0;
 628
 629         _EXTERN_FUNC_EXIT;
 630         return ret;
 631 }
 632
 633 int _busy_handler(void *pData, int count)
 634 {
 635         _INNER_FUNC_ENTER;
 636
 637         _DEBUG_TRACE("__busy_handler %d called", count);
 638
 639         /*  sleep time when SQLITE_LOCK */
 640         usleep(100000);
 641
 642         _INNER_FUNC_EXIT;
 643         /* retry will be stopped if  busy handler return 0 */
 644         return RETRY_COUNT - count;
 645 }
 646
 647 DM_ERROR _query_exec(DB_HANDLER * db_handler, char *query, char *errMsg)
 648 {
 649         _INNER_FUNC_ENTER;
 650
 651         char *queryMsg = 0;
 652         int ret = 0;
 653
 654         retvm_if(db_handler == NULL, DM_ERR_UNKNOWN, "db handler is NULL !!");
 655
 656         ret = sqlite3_exec(db_handler, query, 0, 0, &queryMsg);
 657         if (ret != SQLITE_OK) {
 658                 _DEBUG_TRACE("%s(%d) : %s", errMsg, ret, queryMsg);
 659
 660                 if (queryMsg != NULL)
 661                         sqlite3_free(queryMsg);
 662
 663 /*
 664                 if (ret == SQLITE_BUSY)
 665                         return DM_ERR_UNKNOWN;
 666 */
 667                 _INNER_FUNC_EXIT;
 668                 return DM_ERR_UNKNOWN;
 669         }
 670         return DM_OK;
 671         _INNER_FUNC_EXIT;
 672 }
 673
 674 db_stmt __query_prepare(DB_HANDLER * db_handler, char *query, int size)
 675 {
 676         _INNER_FUNC_ENTER;
 677
 678         int ret = 0;
 679         db_stmt stmt = 0;
 680
 681         ret = sqlite3_prepare_v2(db_handler, query, size, &stmt, 0);
 682         if (ret != SQLITE_OK)
 683                 _DEBUG_VERBOSE("sqlite3_query_prepare failed(%d) : %s ", ret, sqlite3_errmsg(db_handler));
 684
 685         _INNER_FUNC_EXIT;
 686
 687         return stmt;
 688 }
 689
 690 DM_ERROR __stmt_bind_text(DB_HANDLER * db_handler, db_stmt stmt, int index, const char *value)
 691 {
 692         _INNER_FUNC_ENTER;
 693
 694         int ret = 0;
 695
 696         if (value != NULL) {
 697                 ret = sqlite3_bind_text(stmt, index, value, strlen(value), SQLITE_STATIC);
 698         } else {
 699                 ret = ___stmt_bind_null(db_handler, stmt, index);
 700                 if (ret == DM_OK) {
 701                         ret = SQLITE_OK;
 702                 }
 703         }
 704
 705         if (ret != SQLITE_OK) {
 706                 _DEBUG_VERBOSE("sqlite3_stmt_bind_text failed(%d) : %s ", ret, sqlite3_errmsg(db_handler));
 707                 _INNER_FUNC_EXIT;
 708                 return DM_ERR_UNKNOWN;
 709         }
 710         _INNER_FUNC_EXIT;
 711         return DM_OK;
 712 }
 713
 714 DM_ERROR _stmt_bind_int(DB_HANDLER * db_handler, db_stmt stmt, int index, const int value)
 715 {
 716         _INNER_FUNC_ENTER;
 717
 718         int ret = 0;
 719
 720         ret = sqlite3_bind_int(stmt, index, value);
 721         if (ret != SQLITE_OK) {
 722                 _DEBUG_TRACE("sqlite3_stmt_bind_int failed(%d) : %s \n", ret, sqlite3_errmsg(db_handler));
 723                 _INNER_FUNC_EXIT;
 724                 return DM_ERR_UNKNOWN;
 725         }
 726
 727         _INNER_FUNC_EXIT;
 728
 729         return DM_OK;
 730 }
 731
 732 DM_ERROR ___stmt_bind_null(DB_HANDLER * db_handler, db_stmt stmt, int index)
 733 {
 734         _INNER_FUNC_ENTER;
 735
 736         int ret = 0;
 737
 738         ret = sqlite3_bind_null(stmt, index);
 739         if (ret != SQLITE_OK) {
 740                 _DEBUG_VERBOSE("sqlite3_stmt_bind_null failed(%d) : %s", ret, sqlite3_errmsg(db_handler));
 741                 _INNER_FUNC_EXIT;
 742                 return DM_ERR_UNKNOWN;
 743         }
 744
 745         _INNER_FUNC_EXIT;
 746         return DM_OK;
 747 }
 748
 749 DM_ERROR __stmt_step(DB_HANDLER * db_handler, db_stmt stmt)
 750 {
 751         _INNER_FUNC_ENTER;
 752         int ret = 0;
 753
 754         ret = sqlite3_step(stmt);
 755
 756         if (ret == SQLITE_ROW) {
 757                 _INNER_FUNC_EXIT;
 758                 return DM_ERR_MORE_DATA;
 759         }
 760
 761         if (ret != SQLITE_DONE) {
 762                 _DEBUG_VERBOSE("sqlite3_stmt_step failed(%d) : %s", ret, sqlite3_errmsg(db_handler));
 763
 764 /*              if (ret == SQLITE_BUSY)
 765                         return DM_ERR_UNKNOWN;*/
 766                 _INNER_FUNC_EXIT;
 767                 return DM_ERR_UNKNOWN;
 768         }
 769
 770         _INNER_FUNC_EXIT;
 771         return DM_OK;
 772 }
 773
 774 /*DM_ERROR __stmt_reset(DB_HANDLER *db_handler, db_stmt stmt)
 775 {
 776         int ret = 0;
 777
 778         if (sqlite3_reset(stmt) != SQLITE_OK) {
 779                 _DEBUG_INFO("sqlite3_stmt_reset failed(%d) : %s", ret, sqlite3_errmsg(db_handler));
 780                 return DM_ERR_UNKNOWN;
 781         }
 782
 783         return DM_OK;
 784 }*/
 785
 786 DM_ERROR __stmt_finalize(DB_HANDLER * db_handler, db_stmt stmt)
 787 {
 788         _INNER_FUNC_ENTER;
 789         int ret = 0;
 790
 791         if (sqlite3_finalize(stmt) != SQLITE_OK) {
 792                 _DEBUG_VERBOSE("sqlite3_stmt_finalize failed(%d) : %s", ret, sqlite3_errmsg(db_handler));
 793                 _INNER_FUNC_EXIT;
 794                 return DM_ERR_UNKNOWN;
 795         }
 796
 797         _INNER_FUNC_EXIT;
 798         return DM_OK;
 799 }
 800
 801 char *_stmt_column_text(db_stmt stmt, int index)
 802 {
 803         _EXTERN_FUNC_ENTER;
 804
 805         char *temp = 0;
 806         temp = (char *)sqlite3_column_text(stmt, index);
 807
 808         _EXTERN_FUNC_EXIT;
 809
 810         return STRDUP(temp);
 811 }
 812
 813 int __stmt_column_int(db_stmt stmt, int index)
 814 {
 815         _INNER_FUNC_ENTER;
 816
 817         _INNER_FUNC_EXIT;
 818         return (int)sqlite3_column_int(stmt, index);
 819 }
 820
 821 DM_ERROR _get_table(DB_HANDLER * db_handler, char *query, char ***result, int *row_count, int *col_count)
 822 {
 823         _EXTERN_FUNC_ENTER;
 824
 825         int ret = 0;
 826         char *errMsg;
 827
 828         if (db_handler == NULL) {
 829                 _EXTERN_FUNC_EXIT;
 830                 return DM_ERR_UNKNOWN;
 831         }
 832
 833         ret = sqlite3_get_table(db_handler, query, result, row_count, col_count, &errMsg);
 834
 835         if (ret != SQLITE_OK) {
 836                 _DEBUG_TRACE("sqlite3_get_table failed(%d) : %s", ret, errMsg);
 837
 838                 __free_table(*result);
 839
 840                 if (errMsg != NULL)
 841                         sqlite3_free(errMsg);
 842
 843                 _EXTERN_FUNC_EXIT;
 844
 845                 return DM_ERR_UNKNOWN;
 846         }
 847
 848         _EXTERN_FUNC_EXIT;
 849
 850         return DM_OK;
 851 }
 852
 853 void __free_table(char **result)
 854 {
 855         _INNER_FUNC_ENTER;
 856
 857         if (result != NULL)
 858                 sqlite3_free_table(result);
 859
 860         _INNER_FUNC_EXIT;
 861
 862 }
 863
 864 int _exist_table(DB_HANDLER * db_handler, const char *table_name)
 865 {
 866         _INNER_FUNC_ENTER;
 867
 868         db_stmt stmt = 0;
 869         int table_count = 0;
 870         char *query = "select count(*) from sqlite_master where tbl_name= ?";
 871
 872         stmt = __query_prepare(db_handler, query, strlen(query));
 873         if ((stmt != NULL) && (__stmt_bind_text(db_handler, stmt, 1, table_name) == DM_ERR_MORE_DATA)) {
 874
 875                 if (__stmt_step(db_handler, stmt) == DM_ERR_MORE_DATA)
 876                         table_count = __stmt_column_int(stmt, 0);
 877
 878                 __stmt_finalize(db_handler, stmt);
 879
 880                 if (table_count > 0) {
 881                         _INNER_FUNC_EXIT;
 882                         return 1;
 883                 }
 884         }
 885
 886         _INNER_FUNC_EXIT;
 887
 888         return 0;
 889 }
 890
 891 int _get_data_count(DB_HANDLER * db_handler, char *query, int size)
 892 {
 893         _INNER_FUNC_ENTER;
 894
 895         db_stmt stmt = 0;
 896         int data_count = 0;
 897
 898         stmt = __query_prepare(db_handler, query, size);
 899         if (stmt != NULL) {
 900                 if (__stmt_step(db_handler, stmt) == DM_ERR_MORE_DATA)
 901                         data_count = __stmt_column_int(stmt, 0);
 902
 903                 __stmt_finalize(db_handler, stmt);
 904         }
 905
 906         _INNER_FUNC_EXIT;
 907
 908         return data_count;
 909 }
 910
 911 static char *_replace_engine_status_value(ENGINE_STATUS_VALUE engine_status_value)
 912 {
 913         _INNER_FUNC_ENTER;
 914
 915         char *temp = 0;
 916
 917         switch (engine_status_value) {
 918         case VALUE_ENGINE_ID:
 919                 temp = "engine_id";
 920                 break;
 921         case VALUE_ENGINE_STATUS:
 922                 temp = "engine_status";
 923                 break;
 924         case VALUE_SERVER_ID:
 925                 temp = "server_id";
 926                 break;
 927         case VALUE_SERVER_URL:
 928                 temp = "server_url";
 929                 break;
 930         case VALUE_CORRELATOR:
 931                 temp = "correlator";
 932                 break;
 933         case VALUE_MO_PATH:
 934                 temp = "mo_path";
 935                 break;
 936         case VALUE_RESULT_STATUS:
 937                 temp = "result_status";
 938                 break;
 939         case VALUE_UI_MODE:
 940                 temp = "ui_mode";
 941                 break;
 942         case VALUE_TASK_ID:
 943                 temp = "task_id";
 944                 break;
 945         case VALUE_UI_NOTI_TYPE:
 946                 temp = "ui_noti_type";
 947                 break;
 948         case VALUE_DOWNLOAD_CLICK:
 949                 temp = "download_click";
 950                 break;
 951         case VALUE_UPDATE_TIME:
 952                 temp = "update_time";
 953                 break;
 954         default:
 955                 temp = 0;
 956         }
 957
 958         _INNER_FUNC_EXIT;
 959
 960         return temp;
 961 }