src/agent/dm-engine/dm_common_engine.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 <stdio.h>
  20
  21 /*sync-agent*/
  22 #include <sync_agent.h>
  23
  24 /*dm-agent*/
  25 #include "common/dm_common_def.h"
  26 #include "common/dm_common.h"
  27 #include "common/util/util.h"
  28 #include "framework/task/oma_dm_task_request.h"
  29 #include "framework/san-parser/pm_sanparser.h"
  30 #include "dm-engine/dm_common_engine.h"
  31 #include "dm-engine/fumo/fumo_engine.h"
  32 #include "dm-engine/lawmo/lawmo_engine.h"
  33 #include "mo-handler/dm_mo_common_internal.h"
  34 #include "mo-handler/dm_mo_common.h"
  35 #include "serviceadapter/dm-phase-handler/dm_phase_handler.h"
  36 #include "serviceadapter/sa_define.h"
  37 #include "serviceadapter/sa_session.h"
  38 #include "serviceadapter/sa_session_internal.h"
  39 #include "ipc_common.h"
  40 #include "ipc_agent.h"
  41
  42 #ifndef OMADM_AGENT_LOG
  43 #undef LOG_TAG
  44 #define LOG_TAG "COMMON_ENGINE"
  45 #endif
  46
  47 static DM_ERROR _change_engine_status(char *server_id, char *full_path, char *correlator, int service_engine_status);
  48
  49 static DM_ERROR _change_engine_status(char *server_id, char *full_path, char *correlator, int service_engine_status)
  50 {
  51         _INNER_FUNC_ENTER;
  52         DM_ERROR ret = DM_OK;
  53
  54         retvm_if((server_id) == NULL, COMMON_ERR_IS_NULL, "full_path is NULL!!");
  55         retvm_if((full_path) == NULL, COMMON_ERR_IS_NULL, "full_path is NULL!!");
  56
  57         int task_id;
  58         task_id = sync_agent_get_self_request_id();
  59         _DEBUG_TRACE("service engine db update");
  60
  61         engine_status *status;
  62
  63         int is_exist = 0;
  64         is_exist = IsExist_Engine_id(service_engine_status);
  65
  66         if (is_exist == 1) {
  67                 ret = Get_Engine_Status(service_engine_status, &status);
  68                 _DEBUG_TRACE("get engine status : %d", ret);
  69         } else {
  70                 status = (engine_status *) calloc(1, sizeof(engine_status));
  71                 _DEBUG_TRACE("get engine status error");
  72         }
  73
  74         if (status == NULL) {
  75                 _DEBUG_TRACE("calloc failed !!");
  76                 ret = COMMON_ERR_ALLOC;
  77                 goto error;
  78         }
  79
  80         if (correlator != NULL) {
  81                 status->correlator = strdup(correlator);
  82         } else {
  83                 status->correlator = NULL;
  84         }
  85
  86         status->engine_status = DM_SERVICE_ING;
  87         status->engine_id = service_engine_status;
  88         status->mo_path = strdup(full_path);
  89         status->server_url = NULL;
  90         status->result_status = DM_OK;
  91         status->server_id = strdup(server_id);
  92         status->task_id = task_id;
  93         status->ui_noti_type = 0;
  94         _DEBUG_INFO("is_exist [%d]", is_exist);
  95         if(is_exist == 0) {
  96                 status->download_click = RESUME_STATUS_DONWLOAD_BEFORE;
  97         } else {
  98                 _DEBUG_INFO("is_exist [%d] , status->download_click [%d] ", is_exist, status->download_click);
  99                 if( (RESUME_STATUS_INSTALL_BEFORE <= status->download_click) && (status->download_click <= RESUME_STATUS_INSTALL_IDLE ) ) {
 100                         status->download_click = RESUME_STATUS_INSTALL_BEFORE;
 101                 } else {
 102                         status->download_click = RESUME_STATUS_DONWLOAD_BEFORE;
 103                 }
 104         }
 105         _DEBUG_INFO("status->download_click [%d]", status->download_click);
 106
 107         //status->ui_mode = ;
 108
 109         /* one engine */
 110         /*      if(IsExist_Engine_id(SERVICE_ENGINE)) {
 111            ret = Delete_Engine_Status(SERVICE_ENGINE);
 112            } */
 113         ret = Update_Engine_Status(status);
 114         _DEBUG_TRACE(" update engine status : %d \n", ret);
 115
 116         if (status != NULL)
 117                 Free_Memory_Engine_Status(&status, 1);
 118
 119         if (ret != DM_OK) {
 120 //              DB_End_Transaction(TRANSACTION_ROLLBACK_);
 121                 goto error;
 122         }
 123         //sleep(10);
 124 /*      ret = Update_Engine_Status_Column(IDLE_ENGINE, VALUE_ENGINE_STATUS, &service_engine_status);
 125         _DEBUG_TRACE(" update engine status : %d \n", ret);
 126         if (ret != DM_OK) {
 127                 DB_End_Transaction(TRANSACTION_ROLLBACK_);
 128                 goto error;
 129         }*/
 130
 131         _INNER_FUNC_EXIT;
 132         return ret;
 133  error:
 134
 135         _DEBUG_TRACE(" end error : %d \n", ret);
 136         _INNER_FUNC_EXIT;
 137         return ret;
 138 }
 139
 140 void init_Dm_Engine()
 141 {
 142         _EXTERN_FUNC_ENTER;
 143
 144         /* always rebooting operation but excepted bootstrap */
 145         reset_devinfo();
 146         reset_devdetail();
 147
 148
 149         _EXTERN_FUNC_EXIT;
 150 }
 151
 152 DM_ERROR engine_replace_start(char *server_id, char *full_path, ENGINE_ID * service_engine_id, int *resultCode, Item * item)
 153 {
 154         _EXTERN_FUNC_ENTER;
 155
 156         DM_ERROR ret = DM_OK;
 157
 158         if (server_id == NULL || full_path == NULL) {
 159                 //(*resultCode) = CLIENT_ERROR;
 160                 ret = COMMON_ERR_IS_NULL;
 161                 goto error;
 162         }
 163
 164         sync_agent_dm_mo_error_e err_code = SYNC_AGENT_DM_MO_SUCCESS;
 165         sync_agent_dm_mo_type_e mo_type;
 166         char *value = NULL;
 167
 168         err_code = sync_agent_get_mo_type(full_path, &mo_type);
 169         _DEBUG_INFO("get mo type result : %d", err_code);
 170
 171         (*resultCode) = DM_OK;
 172
 173         _DEBUG_INFO(" ------------------------------------------------------------------------------------------------------------------------------------- ");
 174         _DEBUG_INFO(" mo_type : %d , server id : %s , full_path : %s ", mo_type, server_id, full_path );
 175         _DEBUG_INFO(" ------------------------------------------------------------------------------------------------------------------------------------- ");
 176
 177         switch (mo_type) {
 178         case SYNC_AGENT_DM_MO_TYPE_FUMO:
 179                 _DEBUG_INFO("---------------------------------------------------------------- fumo engine ready for replace cmd --------------------------------------------------------------------- ");
 180                 if (item->private.data != NULL) {
 181                         value = item->private.data;
 182                         _DEBUG_INFO("replace value : %s", value);
 183                         ret = fumo_replace(full_path, value, (FUMO_Error *)resultCode);
 184                         if(ret !=DM_OK) {
 185                                 (*resultCode) = DM_ERR_COMMAND_NOT_ALLOWED;
 186                                 goto error;
 187                         }
 188                 }
 189                 break;
 190         case SYNC_AGENT_DM_MO_TYPE_LAWMO:
 191                 _DEBUG_INFO("---------------------------------------------------------------- lawmo engine ready for replace cmd --------------------------------------------------------------------- ");
 192                 ret = DM_OK; //lawmo_replace(full_path, value, (LAWMO_Result_code *) resultCode, CHECK_OPERATION);
 193 /*
 194                 if(ret !=DM_OK)
 195                         goto error;
 196 */
 197                 break;
 198         default:
 199                 //(*resultCode) = CLIENT_ERROR;
 200                 _DEBUG_INFO(" not existed engine for replace cmd \n");
 201                 break;
 202         }
 203
 204
 205
 206         _DEBUG_INFO("====================result code : %d====================\n", *resultCode);
 207         _DEBUG_INFO(" end!!  resut code : %d\n", *resultCode);
 208         _EXTERN_FUNC_EXIT;
 209         return ret;
 210  error:
 211
 212         _DEBUG_INFO("====================result code : %d====================\n", *resultCode);
 213         _DEBUG_INFO(" error end %d  result code : %d", ret, *resultCode);
 214         _EXTERN_FUNC_EXIT;
 215         return ret;
 216 }
 217
 218 DM_ERROR engine_start(char *server_id, char *full_path, char *correlator, ENGINE_ID * service_engine_id, int *resultCode)
 219 {
 220         _EXTERN_FUNC_ENTER;
 221
 222         DM_ERROR ret = DM_OK;
 223
 224         if (server_id == NULL || full_path == NULL) {
 225                 (*resultCode) = CLIENT_ERROR;
 226                 ret = COMMON_ERR_IS_NULL;
 227                 goto error;
 228         }
 229
 230         sync_agent_dm_mo_error_e err_code = SYNC_AGENT_DM_MO_SUCCESS;
 231         sync_agent_dm_mo_type_e mo_type;
 232
 233         err_code = sync_agent_get_mo_type(full_path, &mo_type);
 234         _DEBUG_INFO("get mo type result : %d", err_code);
 235
 236         (*resultCode) = DM_ERR_ACCEPTED_FOR_PROCESSING;
 237
 238         _DEBUG_INFO(" ------------------------------------------------------------------------------------------------------------------------------------- ");
 239         _DEBUG_INFO(" mo_type : %d , server id : %s , full_path : %s , correlator : %s  ", mo_type, server_id, full_path, correlator);
 240         _DEBUG_INFO(" ------------------------------------------------------------------------------------------------------------------------------------- ");
 241
 242         switch (mo_type) {
 243         case SYNC_AGENT_DM_MO_TYPE_FUMO:
 244
 245                 _DEBUG_INFO("---------------------------------------------------------------- fumo engine ready --------------------------------------------------------------------- ");
 246                 ret = _change_engine_status(server_id, full_path, correlator, FUMO_SERVICE_ENGINE);
 247                 if (ret != DM_OK)
 248                         goto error;
 249
 250                 if (correlator == NULL) {
 251                         /*because of gcf server */
 252                         /*ret = fumo_exec(full_path, correlator, (FUMO_Error *)resultCode);
 253                            if(ret !=DM_OK)
 254                            goto error; */
 255                 }
 256
 257                 *service_engine_id = FUMO_SERVICE_ENGINE;
 258
 259                 break;
 260         case SYNC_AGENT_DM_MO_TYPE_LAWMO:
 261                 _DEBUG_INFO("---------------------------------------------------------------- lawmo engine ready --------------------------------------------------------------------- ");
 262                 ret = _change_engine_status(server_id, full_path, correlator, LAWMO_SERVICE_ENGINE);
 263                 if (ret != DM_OK)
 264                         goto error;
 265
 266                 //if( !correlator) {
 267                 // 1 : this is just check , available operation
 268                 ret = lawmo_exec(full_path, correlator, (LAWMO_Result_code *) resultCode, CHECK_OPERATION);
 269                 if (ret != DM_OK)
 270                         goto error;
 271                 //}
 272
 273                 *service_engine_id = LAWMO_SERVICE_ENGINE;
 274
 275                 break;
 276         default:
 277                 (*resultCode) = CLIENT_ERROR;
 278                 _DEBUG_INFO(" not existed engine \n");
 279                 break;
 280         }
 281
 282         _DEBUG_INFO("====================result code : %d====================\n", *resultCode);
 283         _DEBUG_INFO(" end!!  resut code : %d\n", *resultCode);
 284         _EXTERN_FUNC_EXIT;
 285         return ret;
 286  error:
 287
 288         _DEBUG_INFO("====================result code : %d====================\n", *resultCode);
 289         _DEBUG_INFO(" error end %d  result code : %d", ret, *resultCode);
 290         _EXTERN_FUNC_EXIT;
 291         return ret;
 292 }
 293
 294 DM_ERROR service_engine_start(ENGINE_ID service_engine_id, DM_ERROR * service_ret)
 295 {
 296         _EXTERN_FUNC_ENTER;
 297
 298         _DEBUG_INFO(" start : service_engine_id : %d", service_engine_id);
 299         DM_ERROR ret = DM_OK;
 300         engine_status *service_status = NULL;
 301         engine_status *after_service_status = NULL;
 302         char *full_path = NULL;
 303         char *correlator = NULL;
 304         char *server_id = NULL;
 305         int service_engine_status;
 306         bool cancel_flag = 0;
 307
 308         cancel_flag = sync_agent_check_cancel_flag();
 309         if (cancel_flag != 0) {
 310                 ret = DM_ERR_OPERATION_CANCELLED;
 311                 goto error;
 312         }
 313
 314         if (IsExist_Engine_id(service_engine_id) == 1) {
 315
 316                 _DEBUG_INFO("service engine id = %d\n", service_engine_id);
 317                 _DEBUG_INFO(" engine must re-start");
 318
 319                 ret = Get_Engine_Status(service_engine_id, &service_status);
 320                 _DEBUG_INFO(" get engine status : %d \n", ret);
 321                 if (ret != DM_OK)
 322                         goto error;
 323
 324                 if (service_status == NULL) {
 325                         _DEBUG_INFO("service status is null");
 326                         ret = COMMON_ERR_IS_NULL;
 327                         goto error;
 328                 }
 329
 330                 if (service_status->engine_status == DM_SERVICE_UNKNOWN) {
 331                         _DEBUG_INFO("engine status unknown");
 332                         goto error;
 333                 }
 334
 335                 if (service_status->engine_status == DM_SERVICE_ING) {
 336                         _DEBUG_INFO("-------------------------------------------- service type ------------------------------------------------ : %d", service_engine_id);
 337
 338                         int engine_return = OPERATION_SUCCEEDED;
 339
 340                         if (service_status->mo_path != NULL) {
 341                                 full_path = strdup(service_status->mo_path);
 342                                 _DEBUG_INFO("full path : %s ", full_path);
 343                         } else {
 344                                 ret = COMMON_ERR_INTERNAL_NOT_DEFINED;
 345                                 goto error;
 346                         }
 347
 348                         if (service_status->server_id != NULL) {
 349                                 server_id = strdup(service_status->server_id);
 350                                 _DEBUG_INFO("server_id : %s", server_id);
 351                         } else {
 352                                 ret = COMMON_ERR_INTERNAL_NOT_DEFINED;
 353                                 goto error;
 354                         }
 355
 356                         if (service_status->correlator != NULL) {
 357                                 correlator = strdup(service_status->correlator);
 358                                 _DEBUG_INFO("correlator : %s", correlator);
 359                         }
 360
 361                         _DEBUG_INFO("service engine_status : %d", service_status->engine_status);
 362                         _DEBUG_INFO("service result_status : %d", service_status->result_status);
 363
 364                         switch (service_engine_id) {
 365                         case FUMO_SERVICE_ENGINE:
 366                                 _DEBUG_INFO(" service_status->download_click [%d] ", service_status->download_click);
 367                                 if( (service_status->result_status == FUMO_USER_CANCELLED) || (service_status->result_status == FUMO_DOWNLOAD_FAILS_DUE_TO_DEVICE_OUT_OF_MEMORY) ) {
 368                                         _DEBUG_INFO("fota result user_cancelled or not_enough_space report  -- fumo exec is not execution");
 369                                 } else {
 370                                         _DEBUG_INFO(" fumo exec");
 371                                         ret = fumo_exec(full_path, correlator, (FUMO_Error *) (&engine_return));
 372                                 }
 373                                 _DEBUG_INFO("fumo ret : %d", ret);
 374                                 *service_ret = ret;
 375                                 if (ret != DM_OK && ret != DM_ERR_USER_CANDELLED && ret != DM_ERR_REMINDER_INTERVAL && ret != DM_OVER_MEMORY_ERROR /*|| ret != DM_ERR_DEVICE_ABORTED */ )
 376                                         goto error;
 377                                 break;
 378                         case LAWMO_SERVICE_ENGINE:
 379                                 _DEBUG_INFO(" lawmo exec");
 380                                 ret = lawmo_exec(full_path, correlator, (LAWMO_Result_code *) (&engine_return), NON_CHECK_OPERATION);
 381                                 _DEBUG_INFO("lawmo ret : %d", ret);
 382                                 *service_ret = ret;
 383                                 if (ret != DM_OK)
 384                                         goto error;
 385                                 break;
 386                         default:
 387                                 break;
 388                         }
 389                         _DEBUG_INFO("exe resutlt : %d , server id : %s", engine_return, server_id);
 390                         _DEBUG_INFO("correlator : %s", correlator);
 391
 392                         ret = Get_Engine_Status(service_engine_id, &after_service_status);
 393                         _DEBUG_INFO(" get engine status : %d \n", ret);
 394                         if (ret != DM_OK)
 395                                 goto error;
 396
 397                         if (after_service_status == NULL) {
 398                                 _DEBUG_INFO("service status is null");
 399                                 ret = COMMON_ERR_IS_NULL;
 400                                 goto error;
 401                         }
 402
 403                         _DEBUG_INFO(" after_service_status->download_click [%d] ", after_service_status->download_click);
 404
 405                         if (after_service_status->download_click != RESUME_STATUS_INSTALL_BEFORE) {
 406
 407                                 /*engine status generic alert status */
 408                                 service_engine_status = DM_GENERICALERT_ING;
 409                                 ret = Update_Engine_Status_Column(service_engine_id, VALUE_ENGINE_STATUS, &service_engine_status);
 410                                 _DEBUG_INFO("ret [%d] : service engine status generic alert", ret);
 411
 412                                 if( (service_status->result_status == FUMO_USER_CANCELLED) || (service_status->result_status == FUMO_DOWNLOAD_FAILS_DUE_TO_DEVICE_OUT_OF_MEMORY) ) {
 413                                         _DEBUG_INFO("-- fota result user_cancelled or not_enough_space report  -- ");
 414                                 } else {
 415                                         ret = Update_Engine_Status_Column(service_engine_id, VALUE_RESULT_STATUS, &engine_return);
 416                                         _DEBUG_INFO("ret [%d] : service engine status generic alert status : %d", ret, engine_return);
 417                                         if(engine_return == FUMO_DOWNLOAD_FAILS_DUE_TO_DEVICE_OUT_OF_MEMORY) {
 418                                                 _DEBUG_INFO("service_status->result_status [%d] will be updated to engine_return[%d]", service_status->result_status, engine_return);
 419                                                 service_status->result_status = engine_return;
 420                                         }
 421                                 }
 422
 423                                 /* adding alert for fota result start : _generate_generic_alert*/
 424                                 if( (after_service_status->download_click == RESUME_STATUS_INSTALL) && (service_engine_id == FUMO_SERVICE_ENGINE) ) {
 425                                         // fota UA success or failed.
 426                                         _DEBUG_INFO("fota result report");
 427                                         int isFinish = 0;
 428                                         void *session = NULL;
 429                                         ret = genericalert_operation(&session, &isFinish, service_engine_id);
 430                                         _DEBUG_INFO("ret [%d] , isFinish [%d]", ret, isFinish);
 431
 432                                         set_engine_status_idle(FUMO_SERVICE_ENGINE);
 433                                         Delete_Engine_Status(FUMO_SERVICE_ENGINE);
 434                                         _DEBUG_INFO("Delete fumo service engine");
 435                                         ret = set_current_fumo_state(DM_FUMO_STATE, IDLE_START);
 436                                         _DEBUG_INFO("set_current_fumo_state ret [%d] ", ret);
 437
 438                                         if(ret != DM_OK) {
 439                                                 goto error;
 440                                         }
 441
 442                                         //_DEBUG_INFO("isFinish [%d]", isFinish);
 443                                         //if(!isFinish) {
 444                                         if(engine_return == 200) {
 445                                                 ret = management_phase(1, (Session **) (&session), NULL, &service_engine_id, &isFinish);
 446                                                 if (ret != DM_OK) {
 447                                                         *service_ret = ret;
 448                                                         _DEBUG_INFO("management_phase is not DM_OK");
 449                                                         goto error;
 450                                                 } else {
 451                                                         _DEBUG_INFO("management_phase is DM_OK");
 452                                                 }
 453                                         }
 454                                 } else {
 455                                         if( ( (service_status->result_status == FUMO_USER_CANCELLED) || (service_status->result_status == FUMO_DOWNLOAD_FAILS_DUE_TO_DEVICE_OUT_OF_MEMORY) )
 456                                                 && (service_engine_id == FUMO_SERVICE_ENGINE) ) {
 457                                                 _DEBUG_INFO("fota result user_cancelled or not_enough_space report");
 458                                                 int isFinish = 0;
 459                                                 void *session = NULL;
 460                                                 ret = genericalert_operation(&session, &isFinish, service_engine_id);
 461                                                 _DEBUG_INFO("ret [%d] , isFinish [%d]", ret, isFinish);
 462
 463                                                 set_engine_status_idle(FUMO_SERVICE_ENGINE);
 464                                                 Delete_Engine_Status(FUMO_SERVICE_ENGINE);
 465                                                 _DEBUG_INFO("Delete fumo service engine");
 466                                                 ret = set_current_fumo_state(DM_FUMO_STATE, IDLE_START);
 467                                                 _DEBUG_INFO("set_current_fumo_state ret [%d] ", ret);
 468
 469                                                 if(ret != DM_OK) {
 470                                                         goto error;
 471                                                 }
 472                                         }
 473                                 }
 474                                 /* adding alert for fota result end */
 475                         }else {
 476                                 // download completed -> later -> user canceled.
 477                                 if( (service_status->result_status == FUMO_USER_CANCELLED) || (service_status->result_status == FUMO_DOWNLOAD_FAILS_DUE_TO_DEVICE_OUT_OF_MEMORY) ) {
 478                                         _DEBUG_INFO("fota result user_cancelled or not_enough_space report");
 479                                         int isFinish = 0;
 480                                         void *session = NULL;
 481
 482                                         service_engine_status = DM_GENERICALERT_ING;
 483                                         ret = Update_Engine_Status_Column(service_engine_id, VALUE_ENGINE_STATUS, &service_engine_status);
 484                                         _DEBUG_INFO("ret [%d] : service engine status generic alert", ret);
 485
 486                                         ret = genericalert_operation(&session, &isFinish, service_engine_id);
 487                                         _DEBUG_INFO("ret [%d] , isFinish [%d]", ret, isFinish);
 488
 489                                         set_engine_status_idle(FUMO_SERVICE_ENGINE);
 490                                         Delete_Engine_Status(FUMO_SERVICE_ENGINE);
 491                                         _DEBUG_INFO("Delete fumo service engine");
 492                                         ret = set_current_fumo_state(DM_FUMO_STATE, IDLE_START);
 493                                         _DEBUG_INFO("set_current_fumo_state ret [%d] ", ret);
 494
 495                                         if(ret != DM_OK) {
 496                                                 goto error;
 497                                         }
 498
 499                                 }
 500
 501                         }
 502
 503                         str_free(&full_path);
 504                         str_free(&correlator);
 505                         str_free(&server_id);
 506
 507                         if (service_status != NULL) {
 508                                 Free_Memory_Engine_Status(&service_status, 1);
 509                         }
 510                         if (after_service_status != NULL) {
 511                                 Free_Memory_Engine_Status(&after_service_status, 1);
 512                         }
 513
 514                 } else {
 515
 516                         if( (service_status->result_status == FUMO_USER_CANCELLED) || (service_status->result_status == FUMO_DOWNLOAD_FAILS_DUE_TO_DEVICE_OUT_OF_MEMORY) ) {
 517                                 _DEBUG_INFO("fota result user_cancelled report");
 518                                 int isFinish = 0;
 519                                 void *session = NULL;
 520                                 ret = genericalert_operation(&session, &isFinish, service_engine_id);
 521                                 _DEBUG_INFO("ret [%d] , isFinish [%d]", ret, isFinish);
 522
 523                                 set_engine_status_idle(service_engine_id);
 524                                 Delete_Engine_Status(service_engine_id);
 525                                 _DEBUG_INFO("Delete fumo service engine");
 526                                 ret = set_current_fumo_state(DM_FUMO_STATE, IDLE_START);
 527                                 _DEBUG_INFO("set_current_fumo_state ret [%d] ", ret);
 528
 529                                 if(ret != DM_OK) {
 530                                         goto error;
 531                                 }
 532                         }
 533
 534                         if (service_status != NULL) {
 535                                 Free_Memory_Engine_Status(&service_status, 1);
 536                         }
 537                         _DEBUG_INFO(" non service engine ing");
 538                 }
 539
 540         } else {
 541                 _DEBUG_INFO(" non service engine ");
 542         }
 543
 544         _EXTERN_FUNC_EXIT;
 545         return ret;
 546
 547  error:
 548         if (service_status != NULL) {
 549                 Free_Memory_Engine_Status(&service_status, 1);
 550         }
 551
 552         if (after_service_status != NULL) {
 553                 Free_Memory_Engine_Status(&after_service_status, 1);
 554         }
 555
 556         str_free(&full_path);
 557         str_free(&correlator);
 558         str_free(&server_id);
 559         _DEBUG_INFO(" error end %d ", ret);
 560         _EXTERN_FUNC_EXIT;
 561         return ret;
 562 }
 563
 564 DM_ERROR set_engine_status_idle(ENGINE_ID service_engine_id)
 565 {
 566         _EXTERN_FUNC_ENTER;
 567
 568         DM_ERROR ret = DM_OK;
 569
 570         if (IsExist_Engine_id(service_engine_id) == 1) {
 571                 _DEBUG_INFO("service engine id = %d\n", service_engine_id);
 572         }
 573
 574         ret = set_end_engine_status_idle();
 575         if (ret != DM_OK)
 576                 goto error;
 577
 578         _EXTERN_FUNC_EXIT;
 579         return ret;
 580  error:
 581         _DEBUG_INFO(" error end %d ", ret);
 582         _EXTERN_FUNC_EXIT;
 583         return ret;
 584 }
 585
 586 DM_ERROR set_end_engine_status_idle()
 587 {
 588         _EXTERN_FUNC_ENTER;
 589
 590         DM_ERROR ret = DM_OK;
 591
 592         int common_engine_status = DM_IDLE;
 593         _DEBUG_INFO(" engine idle");
 594         ret = Update_Engine_Status_Column(IDLE_ENGINE, VALUE_ENGINE_STATUS, &common_engine_status);
 595         if (ret != DM_OK)
 596                 goto error;
 597
 598         _EXTERN_FUNC_EXIT;
 599         return ret;
 600
 601  error:
 602         _DEBUG_INFO(" error end %d ", ret);
 603         _EXTERN_FUNC_EXIT;
 604         return ret;
 605 }
 606
 607 DM_ERROR dm_common_start(Event_Contents * pEvent_data)
 608 {
 609         _EXTERN_FUNC_ENTER;
 610
 611         DM_ERROR ret = DM_OK;
 612
 613         retvm_if((pEvent_data) == NULL, COMMON_ERR_IS_NULL, "pEvent_data is NULL!!");
 614
 615         ret = dm_common_operation(pEvent_data);
 616         if (ret != DM_OK) {
 617                 goto error;
 618         }
 619
 620         _EXTERN_FUNC_EXIT;
 621         return ret;
 622  error:
 623
 624         _DEBUG_INFO(" end!! error : %d\n", ret);
 625         _EXTERN_FUNC_EXIT;
 626         return ret;
 627
 628 }
 629
 630 DM_ERROR dm_common_operation(Event_Contents * pEvent_data)
 631 {
 632         _EXTERN_FUNC_ENTER;
 633
 634         DM_ERROR ret = DM_OK;
 635
 636         retvm_if((pEvent_data) == NULL, COMMON_ERR_IS_NULL, "pEvent_data is NULL!!");
 637
 638         int return_ret = 0;
 639         return_ret = remove(OMA_DM_MSG_PATH);
 640         _DEBUG_INFO(" result file remove /tmp/dm.txt =[%d]\n", return_ret);
 641
 642         DM_ERROR service_ret = DM_OK;
 643         ENGINE_ID service_engine_id = NO_SERVICE_ENGINE;
 644         char *session_id = NULL;
 645         char *server_id = NULL;
 646         int session_type = UI_EVENT;
 647
 648         ret = get_server_info(pEvent_data, &server_id, &session_id, &session_type);
 649         if (ret != DM_OK) {
 650                 goto error;
 651         }
 652
 653         if( session_id != NULL ) {
 654                 _DEBUG_INFO("session_id [%s]", session_id);
 655         } else {
 656                 _DEBUG_INFO("session_id is NULL");
 657         }
 658         _DEBUG_INFO("session_type [%d]", session_type);
 659
 660         get_service_engine_id(&service_engine_id, pEvent_data->ui_mode);
 661
 662         /*pkg 1 ~ pkg2 */
 663         int isFinish = 0;
 664         int isgeneticAlert = 0;
 665         void *session = NULL;
 666         _DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
 667         _DEBUG_INFO(" setupphase Msg \n");
 668         _DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
 669         ret = setup_phase(1, (Session **) & session, server_id, session_id, session_type, &service_engine_id, &isFinish, isgeneticAlert);
 670         if (ret != DM_OK) {
 671                 _DEBUG_INFO("connect to server fail in dm common operation (authentication fail or network fail)");
 672                 _DEBUG_INFO(" result =[%d]\n", ret);
 673                 service_ret = ret;
 674                 goto error;
 675         }
 676
 677         while (!isFinish) {
 678
 679                 /* pkg 3 ~ pkg 4 */
 680                 /*isFinish = 0; */
 681                 _DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
 682                 _DEBUG_INFO(" management Msg \n");
 683                 _DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
 684                 ret = management_phase(1, (Session **) (&session), NULL, &service_engine_id, &isFinish);
 685                 if (ret != DM_OK) {
 686                         service_ret = ret;
 687                         goto error;
 688                 }
 689
 690                 _DEBUG_INFO("isFinish : %d\n", isFinish);
 691                 _DEBUG_INFO("----------------------------------------------------------------------------------------------------------\n");
 692
 693                 ret = service_engine_start(service_engine_id, &service_ret);
 694                 if (ret != DM_OK)
 695                         goto error;
 696
 697                 ret = genericalert_operation(&session, &isFinish, service_engine_id);
 698                 if (ret != DM_OK)
 699                         goto error;
 700
 701                 set_engine_status_idle(service_engine_id);
 702         }
 703
 704         terminate_oma_dm_ui(service_ret, service_engine_id);
 705
 706         _EXTERN_FUNC_EXIT;
 707         return ret;
 708
 709  error:
 710
 711         terminate_oma_dm_ui(service_ret, service_engine_id);
 712
 713         if (ret == DM_ERR_OPERATION_CANCELLED && service_ret == DM_ERR_OPERATION_CANCELLED) {
 714                 Delete_Engine_Status(service_engine_id);
 715                 _DEBUG_INFO("Delete fumo service engine");
 716         }
 717
 718         set_engine_status_idle(service_engine_id);
 719
 720         if (service_engine_id != NO_SERVICE_ENGINE) {
 721
 722                 if (service_engine_id != FUMO_SERVICE_ENGINE && check_existed_fumo_reminder_interval() == 0) {
 723                         Delete_Engine_Status(service_engine_id);
 724                         _DEBUG_INFO("Delete fumo service engine");
 725                 }
 726         }
 727
 728         _DEBUG_INFO(" end error ret : %d\n", ret);
 729         _EXTERN_FUNC_EXIT;
 730         return ret;
 731 }
 732
 733 DM_ERROR genericalert_operation(void **session, int *isFinish, ENGINE_ID service_engine_id)
 734 {
 735
 736         _EXTERN_FUNC_ENTER;
 737
 738         DM_ERROR ret = DM_OK;
 739         char *pServer_id = NULL;
 740         engine_status *status = NULL;
 741
 742         if (IsExist_Engine_id(service_engine_id) == 1) {
 743                 ret = Get_Engine_Status(service_engine_id, &status);
 744                 if (ret != DM_OK)
 745                         goto error;
 746                 _DEBUG_INFO(" result =[%d]\n", ret);
 747
 748                 _DEBUG_INFO("server id : %s", status->server_id);
 749                 _DEBUG_INFO("engine_id : %d", status->engine_id);
 750                 _DEBUG_INFO("correlator : %s", status->correlator);
 751                 _DEBUG_INFO("engine_status : %d", status->engine_status);
 752                 _DEBUG_INFO("result status : %d", status->result_status);
 753                 _DEBUG_INFO("mo path : %s", status->mo_path);
 754                 _DEBUG_INFO("server url : %s", status->server_url);
 755
 756                 if (status->engine_status == DM_GENERICALERT_ING) {
 757                         _DEBUG_INFO(" ----------------------------------------------------------------------generic alert-------------------------------------------------------------------------------");
 758                         _DEBUG_INFO("service engine id = %d\n", service_engine_id);
 759
 760                         *isFinish = 0;
 761                         int isgeneticAlert = 1;
 762
 763                         if (status->server_id != NULL) {
 764                                 pServer_id = strdup(status->server_id);
 765                                 _DEBUG_INFO(" server id is %s", status->server_id);
 766                         } else {
 767                                 _DEBUG_INFO(" server id is NULL");
 768                                 ret = COMMON_ERR_IS_NULL;
 769                                 goto error;
 770                         }
 771                         //void * session = NULL;
 772
 773                         ret = generic_alert(1, (Session **) session, pServer_id, NULL, isFinish, isgeneticAlert, service_engine_id, status->result_status);
 774                         if (ret != DM_OK)
 775                                 goto error;
 776                         _DEBUG_INFO(" result =[%d]\n", ret);
 777
 778                         /*update engine_status */
 779                         status->engine_status = DM_SERVICE_UNKNOWN;
 780                         ret = Update_Engine_Status(status);
 781                         _DEBUG_INFO(" update engine status : %d \n", ret);
 782
 783                         str_free(&pServer_id);
 784                 }else {
 785                         _DEBUG_INFO("non generic alert");
 786                 }
 787         } else {
 788                 _DEBUG_INFO("IsExist_Engine_id(%d) value is not 1", service_engine_id);
 789         }
 790
 791         if (status != NULL) {
 792                 Free_Memory_Engine_Status(&status, 1);
 793         }
 794
 795         _EXTERN_FUNC_EXIT;
 796         return ret;
 797
 798  error:
 799
 800         str_free(&pServer_id);
 801         if (status != NULL)
 802                 Free_Memory_Engine_Status(&status, 1);
 803
 804         _DEBUG_INFO(" error end  ret : %d\n", ret);
 805         _EXTERN_FUNC_EXIT;
 806         return ret;
 807
 808 }