src/plugins/dm-private/slp-device-dm/src/plugin_slp_device_ctrl.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 #include <stdbool.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <wait.h>
  24 #include <errno.h>
  25 #include <vconf.h>
  26 #include <vconf-keys.h>
  27 /*#include "package-manager.h"*/
  28
  29 /*sync-agent*/
  30 #include <sync_agent.h>
  31
  32 #include "plugin_slp_device_ctrl.h"
  33
  34 #ifndef OMADM_AGENT_LOG
  35 #undef LOG_TAG
  36 #define LOG_TAG "PLUGIN_DEVICE_SLP_DM"
  37 #endif
  38
  39 #define UA_RESULT_KEY "db/SyncML/oma-dm-service/UAresult"
  40
  41 //#define RB_ERR_CODE_MAX_COUNT 16
  42 #define RB_ERR_CODE_MAX_COUNT 20
  43
  44 typedef struct _type_Redbend_OMADM_Table {
  45         int result_code;
  46         char *str_meanning;
  47         char *result_redbend;
  48         char *str_redbend;
  49 } type_redbend_omadm_table_s;
  50
  51 type_redbend_omadm_table_s redbend_omadm_table[RB_ERR_CODE_MAX_COUNT] = {
  52         {200, "Successful",                                                                             "0", NULL},
  53         {410, "UPI_DELTA_PATH_ERROR",                                           "fdaa", NULL},
  54         {410, "UPI_DELTA_PATH_LENGTH_ERROR",                            "fdab", NULL},
  55         {410, "UPI_GUI_INIT_ERROR",                                                     "fdba", NULL},
  56         {410, "UPI_VERSION_ERROR",                                                      "fdbb", NULL},
  57         {410, "UPI_SBL_VERIFY_ERROR",                                           "fdca", NULL},
  58         {410, "UPI_BOOT_VERIFY_ERROR",                                          "fdcb", "kernel verification fail"},
  59         {410, "UPI_PLATFORM_VERIFY_ERROR",                                      "fdcc", "platform verification fail"},
  60         {410, "UPI_CSC_VERIFY_ERROR",                                           "fdcd", "csc verification fail"},
  61         {410, "UPI_MODEM_VERIFY_ERROR",                                                 "fdce", "modem verification fail"},
  62         {410, "UPI_SBL_UPDATE_ERROR",                                           "fdda", "bootloader update fail"},
  63         {410, "UPI_BOOT_UPDATE_ERROR",                                          "fddb", "kernel update fail"},
  64         {410, "UPI_PLATFORM_UPDATE_ERROR",                                      "fddc", "platform update fail"},
  65         {410, "UPI_CSC_UPDATE_ERROR",                                           "fddd", "csc update fail"},
  66         {410, "UPI_MODEM_UPDATE_ERROR",                                                 "fdde", "modem update fail"},
  67         {410, "UPI_INVALID_PARAM_ERROR",                                        "fdea", NULL},
  68         {410, "UPI_STATUSFLAG_ERROR",                                           "fdeb", NULL},
  69         {410, "UPI_DELTACOUNT_ERROR",                                           "fdec", "no delta file"},
  70         {410, "UPI_NO_DELTA_ERROR",                                                     "fdfa", NULL},
  71         {410, "UPI_NO_UA_ERROR",                                                                "fdfb", NULL},
  72
  73 /*{0, NULL, NULL, NULL},*/
  74 };
  75
  76 static int _system_command(const char *command);
  77 /*static int __get_mobile_tracker_status();*/
  78 /*static int __return_pkgmgr_cb(pkg_request_id req_id, const char *pkg_type, const char *pkg_name, const char *key, const char *val, const void *pmsg, void *data);*/
  79
  80 int slp_device_ctrl_set_fota_flag()
  81 { // return value : success[0] faile[1]
  82         _EXTERN_FUNC_ENTER;
  83
  84         /*
  85            2010.09.08 document base
  86            ("echo fota_enable > /sys/devices/platform/s3c_samsung_fota/samsung_fota_config");
  87            _DEBUG_INFO("echo fota_enable > /sys/devices/platform/s3c_samsung_fota/samsung_fota_config \n");
  88            2011.03.23 document base
  89            ("/bin/change-booting-mode.sh --fota /opt/data/fota");
  90          */
  91
  92         int ret = _system_command("/bin/sync");
  93         _DEBUG_INFO("disk sync - ret : [%d]", ret);
  94
  95         _DEBUG_INFO("/bin/change-booting-mode.sh --fota /opt/usr/data/fota/save \n");
  96         ret = system("/bin/change-booting-mode.sh --fota /opt/usr/data/fota/save");
  97         _DEBUG_INFO("change-booting-mode.sh ret : [%d]", ret);
  98
  99         _EXTERN_FUNC_EXIT;
 100         return 0;
 101
 102 /*
 103         int ret = _system_command("/bin/change-booting-mode.sh --fota /opt/data/fota/save");
 104         _DEBUG_INFO("change-booting-mode.sh ret : [%d]", ret);
 105
 106         if (ret != -1) {
 107                 _DEBUG_ERROR("error : %d", ret);
 108
 109                 if(ret == 256) {
 110                         ret = _system_command("reboot fota");
 111                         if(ret != -1) {
 112                                 _EXTERN_FUNC_EXIT;
 113                                 return 1;
 114                         } else {
 115                                 _EXTERN_FUNC_EXIT;
 116                                 return 0;
 117                         }
 118                 }
 119
 120                 _EXTERN_FUNC_EXIT;
 121                 return 1;
 122         } else {
 123                 _EXTERN_FUNC_EXIT;
 124                 return 0;
 125         }
 126 error:
 127         return 0;
 128 */
 129 }
 130
 131 char* slp_device_ctrl_get_fota_fail_ua_result()
 132 {
 133         _EXTERN_FUNC_ENTER;
 134         FILE *file_des;
 135         long lSize = 0;
 136         size_t result;
 137         char file_path[128] = {0,};
 138         snprintf(file_path,128, "%s/cause", /*FOTA_SAVE_DIR*/ "/opt/usr/data/fota/save");
 139         file_des = fopen(file_path, "rb");
 140         if (file_des == NULL) {
 141                 _DEBUG_INFO("fopen fail - cause file \n");
 142                 _EXTERN_FUNC_EXIT;
 143                 return NULL;
 144         }
 145         fseek(file_des, 0, SEEK_END);
 146         lSize = ftell(file_des);
 147         if (lSize <= 0) {
 148                 _DEBUG_INFO("ftell nagative return ");
 149                 if (file_des != NULL)
 150                         fclose(file_des);
 151                 _EXTERN_FUNC_EXIT;
 152                 return NULL;
 153         }
 154         rewind(file_des);
 155         char *str_result = NULL;
 156         //str_result = (char *)calloc(1, lSize + 1);
 157         str_result = (char *)malloc(sizeof(char)*(lSize+1));
 158         if (str_result == NULL) {
 159                 if (file_des != NULL)
 160                         fclose(file_des);
 161                 _DEBUG_INFO("malloc fail \n");
 162                 _EXTERN_FUNC_EXIT;
 163                 return NULL;
 164         }
 165         memset(str_result, 0x0, sizeof(char)*(lSize+1));        // PREVENT
 166
 167         result = fread(str_result, 1, lSize, file_des);
 168         if ((result != lSize) || (str_result == NULL)) {
 169                 if (file_des != NULL)
 170                         fclose(file_des);
 171                 _DEBUG_INFO("read fail or str_result == NULL \n");
 172
 173                 if (str_result != NULL)
 174                         free(str_result);
 175
 176                 _EXTERN_FUNC_EXIT;
 177                 return NULL;
 178         }
 179         if (str_result[lSize - 1] == '\n')
 180                 str_result[lSize - 1] = 0;
 181
 182         _DEBUG_INFO("str_result [%s] \n", str_result);
 183
 184         if (file_des != NULL)
 185                 fclose(file_des);
 186
 187         _EXTERN_FUNC_EXIT;
 188         return str_result;
 189 }
 190
 191 int slp_device_ctrl_get_fota_update_result()
 192 {
 193         _EXTERN_FUNC_ENTER;
 194
 195         int update_result = 400;
 196         FILE *file_des;
 197         long lSize = 0;
 198         long file_data_size = 0;
 199         size_t result;
 200         //file_des = fopen("/opt/result", "rb");
 201         char file_path[128] = {0,};
 202
 203         char * str_cause = NULL;
 204         int vconf_result = 0;
 205         char str_result_merge[128] = {0,};
 206
 207         snprintf(file_path,128, "%s/result", /*FOTA_SAVE_DIR*/ "/opt/usr/data/fota/save");
 208         file_des = fopen(file_path, "rb");
 209
 210         int j = 0;
 211         bool match_found = false;
 212         if (file_des == NULL) {
 213                 _DEBUG_INFO("fopen fail - result file \n");
 214                 _EXTERN_FUNC_EXIT;
 215                 return 400;
 216         }
 217         fseek(file_des, 0, SEEK_END);
 218         lSize = ftell(file_des);
 219         if (lSize <= 0) {
 220                 _DEBUG_INFO("ftell nagative return ");
 221                 if (file_des != NULL)
 222                         fclose(file_des);
 223                 _EXTERN_FUNC_EXIT;
 224                 return 400;
 225         }
 226         rewind(file_des);
 227         char *str_result = NULL;
 228         //str_result = (char *)calloc(1, lSize + 1);
 229         str_result = (char *)malloc(sizeof(char)*(lSize+1));
 230         if (str_result == NULL) {
 231                 if (file_des != NULL)
 232                         fclose(file_des);
 233                 _DEBUG_INFO("malloc fail \n");
 234                 _EXTERN_FUNC_EXIT;
 235                 return 400;
 236         }
 237
 238         memset(str_result, 0x0, sizeof(char)*(lSize+1));        // PREVENT
 239
 240         result = fread(str_result, 1, lSize, file_des);
 241         if ((result != lSize) || (str_result == NULL)) {
 242                 if (file_des != NULL)
 243                         fclose(file_des);
 244                 _DEBUG_INFO("read fail or str_result == NULL \n");
 245
 246                 if (str_result != NULL)
 247                         free(str_result);
 248
 249                 _EXTERN_FUNC_EXIT;
 250                 return 400;
 251         }
 252         if (str_result[lSize - 1] == '\n') {
 253                 str_result[lSize - 1] = 0;
 254                 file_data_size = lSize -1;
 255         } else {
 256                 file_data_size = lSize;
 257         }
 258
 259         for (j = 0; j < RB_ERR_CODE_MAX_COUNT; j++) {
 260                 //if (strlen(str_result) == strlen(redbend_omadm_table[j].result_redbend)) {
 261                 if (file_data_size == strlen(redbend_omadm_table[j].result_redbend)) {
 262                         if ((strcmp(str_result, redbend_omadm_table[j].result_redbend) == 0)) {
 263                                 update_result = redbend_omadm_table[j].result_code;
 264                                 match_found = true;
 265                                 _DEBUG_INFO("Result meanning info [%s] \n", redbend_omadm_table[j].str_meanning);
 266
 267                                 ////////////////////////////////////////////////////////////////////////////////
 268                                 if(redbend_omadm_table[j].str_redbend != NULL) {
 269                                         str_cause = slp_device_ctrl_get_fota_fail_ua_result();
 270                                         if(str_cause == NULL) {
 271                                                 vconf_result = vconf_set_str(UA_RESULT_KEY, redbend_omadm_table[j].str_meanning);
 272                                                 if(vconf_result == 0) {
 273                                                         _DEBUG_VERBOSE("vconf_set_str() success %s [%s]!!", UA_RESULT_KEY, redbend_omadm_table[j].str_meanning);
 274                                 } else {
 275                                                         _DEBUG_VERBOSE("vconf_set_str() %s failed !!", UA_RESULT_KEY);
 276                                                 }
 277                                         } else {
 278                                                 if( strlen(str_cause) > 0 ) {
 279                                                         snprintf(str_result_merge, 120, "%s - %s", redbend_omadm_table[j].str_meanning, str_cause);
 280                                                         vconf_result = vconf_set_str(UA_RESULT_KEY, str_result_merge);
 281                                                         if(vconf_result == 0) {
 282                                                                 _DEBUG_VERBOSE("vconf_set_str() success %s [%s]!!", UA_RESULT_KEY, str_result_merge);
 283                                                         } else {
 284                                                                 _DEBUG_VERBOSE("vconf_set_str() %s failed !!", UA_RESULT_KEY);
 285                                                         }
 286                                                 } else {
 287                                                         vconf_result = vconf_set_str(UA_RESULT_KEY, redbend_omadm_table[j].str_meanning);
 288                                                         if(vconf_result == 0) {
 289                                                                 _DEBUG_VERBOSE("vconf_set_str() success %s [%s]!!", UA_RESULT_KEY, redbend_omadm_table[j].str_meanning);
 290                                                         } else {
 291                                                                 _DEBUG_VERBOSE("vconf_set_str() %s failed !!", UA_RESULT_KEY);
 292                                                         }
 293                                                 }
 294                                         }
 295                                 } else {
 296                                         vconf_result = vconf_set_str(UA_RESULT_KEY, redbend_omadm_table[j].str_meanning);
 297                                         if(vconf_result == 0) {
 298                                                 _DEBUG_VERBOSE("vconf_set_str() success %s [%s]!!", UA_RESULT_KEY, redbend_omadm_table[j].str_meanning);
 299                                         } else {
 300                                                 _DEBUG_VERBOSE("vconf_set_str() %s failed !!", UA_RESULT_KEY);
 301                                         }
 302                                 }
 303                                 ////////////////////////////////////////////////////////////////////////////////
 304
 305                                 break;  /* If existing error code, break-out from the for-loop. */
 306                         }
 307                 }
 308                 if (!match_found)
 309                         update_result = 410;
 310         }
 311
 312         if(!match_found) {
 313                 vconf_result = vconf_set_str(UA_RESULT_KEY, "No find");
 314                 if(vconf_result == 0) {
 315                         _DEBUG_VERBOSE("vconf_set_str() success %s [%s]!!", UA_RESULT_KEY, "No find");
 316                 } else {
 317                         _DEBUG_VERBOSE("vconf_set_str() %s failed !!", UA_RESULT_KEY);
 318                 }
 319         }
 320
 321
 322         if(str_cause != NULL)
 323                 free(str_cause);
 324         if (str_result != NULL)
 325                 free(str_result);
 326
 327         if (file_des != NULL)
 328                 fclose(file_des);
 329
 330         _DEBUG_INFO("update_result - %d \n", update_result);
 331         _EXTERN_FUNC_EXIT;
 332         return update_result;
 333 }
 334
 335 int slp_device_ctrl_reboot()
 336 {
 337         _EXTERN_FUNC_ENTER;
 338
 339         int ret = _system_command("/sbin/reboot");
 340         if (ret != -1) {
 341                 _EXTERN_FUNC_EXIT;
 342                 return 1;
 343         }
 344
 345         /*will be insert.. // tel_process_power_command(TAPI_PHONE_POWER_RESET); ?? */
 346         _EXTERN_FUNC_EXIT;
 347         return 0;
 348 }
 349
 350 int slp_device_ctrl_fully_lock()
 351 {
 352         _EXTERN_FUNC_ENTER;
 353
 354         /*if (__get_mobile_tracker_status() == 0 ) {
 355            _DEBUG_INFO("mobile tracker status OFF \n");
 356            return 0;
 357            }
 358
 359            ("/opt/apps/deb.com.samsung.pwlock/bin/pwlock 1 &");
 360            ("/bin/sync"); */
 361
 362         _EXTERN_FUNC_EXIT;
 363         return 1;
 364 }
 365
 366 int slp_device_ctrl_partially_lock()
 367 {
 368         _EXTERN_FUNC_ENTER;
 369
 370         /*if (__get_mobile_tracker_status() == 0 ) {
 371            _DEBUG_INFO("mobile tracker status OFF \n");
 372            return 0;
 373            }
 374
 375            ("/opt/apps/deb.com.samsung.pwlock/bin/pwlock 1 &");
 376            ("/bin/sync"); */
 377
 378         _EXTERN_FUNC_EXIT;
 379         return 1;
 380 }
 381
 382 int slp_device_ctrl_unlock()
 383 {
 384         _EXTERN_FUNC_ENTER;
 385
 386         /*if (__get_mobile_tracker_status() == 0 ) {
 387            _DEBUG_INFO("mobile tracker status OFF \n");
 388            return 0;
 389            }
 390
 391            ("killall -9 pwlock");
 392            ("/bin/sync"); */
 393         _EXTERN_FUNC_EXIT;
 394         return 1;
 395 }
 396
 397 int slp_device_ctrl_factory_reset()
 398 {
 399         _EXTERN_FUNC_ENTER;
 400
 401         /*if (__get_mobile_tracker_status() == 0 ) {
 402            _DEBUG_INFO("mobile tracker status OFF \n");
 403            return 0;
 404            }
 405            ("/usr/bin/factory-reset.sh"); // */
 406
 407         _EXTERN_FUNC_EXIT;
 408         return 1;
 409 }
 410
 411 /* static function */
 412 static int _system_command(const char *command)
 413 {
 414         _INNER_FUNC_ENTER;
 415
 416         int pid = 0, status = 0;
 417         char *const environ[] = { NULL };
 418
 419         retvm_if((command) == NULL, -1, "command is NULL!!");
 420
 421         pid = fork();
 422         if (pid == -1) {
 423                 _DEBUG_TRACE("ERROR : fork failed to create a process\n");
 424                 _INNER_FUNC_EXIT;
 425                 return -1;
 426
 427         } else if (pid == 0) {
 428                 char *argv[4];
 429                 argv[0] = "sh";
 430                 argv[1] = "-c";
 431                 argv[2] = (char *)command;
 432                 argv[3] = 0;
 433
 434                 execve("/bin/sh", argv, environ);
 435                 abort();
 436         } else {
 437                 do {
 438                         if (waitpid(pid, &status, 0) == -1) {
 439                                 if (errno != EINTR) {
 440                                         _INNER_FUNC_EXIT;
 441                                         return -1;
 442                                 }
 443
 444                         } else {
 445                                 _DEBUG_ERROR("error : status [%d]", status);
 446                                 _INNER_FUNC_EXIT;
 447                                 return status;
 448                         }
 449
 450                 } while (1);
 451         }
 452         _INNER_FUNC_EXIT;
 453         return -1;
 454 }
 455
 456 /* TODO : holding ( wait until the MDM module is completed ) */
 457 /*int Execute_Dev_App_Install(char *file_name, char *application_id)
 458 {
 459     if( file_name == NULL )
 460                 return 0;
 461
 462     _DEBUG_INFO("file_name[%s] \n", file_name);
 463     int result = 0 ;
 464
 465     int req_id = 0;
 466     char *descriptor = NULL;
 467     char abs_setup_file[256] = {0,};
 468     ecore_init();
 469       snprintf(abs_setup_file,sizeof(abs_setup_file),"%s", file_name );
 470       _DEBUG_INFO("[%s] , [%s] \n", abs_setup_file, file_name );
 471     result = package_manager_install_application(&req_id, descriptor, abs_setup_file, PKG_QUIET PKG_DEFAULT, 0, NULL);
 472     LOGTRACE("package_manager_install_application result[%d]\n", result);
 473     if( result < PKG_COMMON_OK) {
 474                 LOGTRACE("Install failed! result[%d] \n", result );
 475                 snprintf(app_ID, PKG_TYPE_STRING_LEN_MAX+PKG_NAME_STRING_LEN_MAX+PKG_VERSION_STRING_LEN_MAX +2 , "%s" , pFile_name );
 476       //pthread_mutex_unlock(&wait_mutex);
 477                 //return 0;
 478     }
 479     else{
 480                 ecore_main_loop_begin();
 481                 snprintf(app_ID, PKG_TYPE_STRING_LEN_MAX+PKG_NAME_STRING_LEN_MAX+PKG_VERSION_STRING_LEN_MAX +2, "%s" , g_pkg_info.pkg_name );
 482     }
 483
 484     ("/bin/sync");
 485
 486     if( result == PKG_COMMON_OK ) {
 487       _DEBUG_INFO("package_manager_install_application() Success !!\n");
 488       result = 0;
 489
 490     } else {
 491       _DEBUG_INFO("package_manager_install_application() Success !!\n");
 492       result = 1;
 493     }
 494
 495     return result ;  // 1(OK),0(FAIL)
 496 }*/
 497
 498 /*int Execute_Dev_App_UnInstall(char *application_id)
 499 {
 500     int result = 0 ;
 501
 502     if( app_ID == NULL )
 503                 return 0 ; // 1(OK),0(FAIL)
 504     LOGTRACE("app_ID[%s] \n", app_ID);
 505
 506     if( strlen(app_ID) >= 256 ) // Prevent defect
 507     {
 508                 LOGTRACE("strlen[app_ID] >= 256 \n");
 509                 return 0 ; // 1(OK),0(FAIL)
 510     }
 511
 512 #if defined(_D_SLP_PKGMGR_)
 513     int req_id = 0;
 514     char *descriptor = NULL;
 515     char pkg_type[16] = {0,};
 516     memcpy(pkg_type,app_ID,3);
 517
 518     ecore_init();
 519     result = package_manager_uninstall_application(&req_id, pkg_type, app_ID , PKG_QUIET PKG_DEFAULT, return_pkgmgr_cb, NULL);
 520     if( result < PKG_COMMON_OK)
 521     {
 522                 LOGTRACE("Uninstall failed! result[%d] \n", result);
 523                 //return 1;
 524     }
 525     else {
 526                 ecore_main_loop_begin();
 527     }
 528 #endif
 529
 530     ("/bin/sync");
 531     if( result == PKG_COMMON_OK ) {
 532                 char return_char[512] = {0,};
 533                 snprintf(return_char,510,"%s,success,%s", (char*)_D_APP_UNINSTALL_,app_ID ); // Prevent defect
 534                 QUEUE_sendto ( _D_SYNCML_DM_SERVICE_SOCKET_PATH , (void*) return_char , strlen(return_char) );
 535     }
 536     else{
 537      char return_char[512] = {0,};
 538      snprintf(return_char,510,"%s,fail,%s", (char*)_D_APP_UNINSTALL_,app_ID ); // Prevent defect
 539      QUEUE_sendto ( _D_SYNCML_DM_SERVICE_SOCKET_PATH , (void*) return_char , strlen(return_char) );
 540     }
 541
 542     return result ;  // 1(OK),0(FAIL)
 543 }*/
 544
 545 /*int Execute_Dev_App_Activate(char *applicaton_id, int activate_status)
 546 {
 547     int result = 0 ;
 548
 549     if( app_ID == NULL )
 550                 return 0 ; // 1(OK),0(FAIL)
 551     LOGTRACE("appID[%s] activate[%d] \n", app_ID, activate);
 552
 553     if( strlen(app_ID) >= 256 ) // Prevent defect
 554     {
 555                 LOGTRACE("strlen[app_ID] >= 256 \n");
 556                 return 0 ; // 1(OK),0(FAIL)
 557     }
 558
 559 #if defined(_D_SLP_PKGMGR_)
 560     int req_id = 0;
 561     char *descriptor = NULL;
 562     char pkg_type[16] = {0,};
 563     memcpy(pkg_type,app_ID,3);
 564
 565     ecore_init();
 566     result = package_manager_activate_application(&req_id, pkg_type, app_ID , activate, return_pkgmgr_cb, NULL);
 567     if( result < PKG_COMMON_OK)
 568     {
 569                 LOGTRACE("Uninstall failed! result[%d] \n", result);
 570                 //return 1;
 571     }
 572     else {
 573                 ecore_main_loop_begin();
 574     }
 575 #endif
 576
 577     ("/bin/sync");
 578     if( result == PKG_COMMON_OK ) {
 579                 char return_char[512] = {0,};
 580                 if( activate ) {
 581                         snprintf(return_char,510,"%s,success,%s", (char*)_D_APP_ACTIVE_,app_ID ); // prevent defect
 582                 }
 583                 else {
 584                         snprintf(return_char,510,"%s,success,%s", (char*)_D_APP_INACTIVE_,app_ID ); // prevent defect
 585                 }
 586
 587                 QUEUE_sendto ( _D_SYNCML_DM_SERVICE_SOCKET_PATH , (void*) return_char , strlen(return_char) );
 588         }
 589     else{
 590                 char return_char[512] = {0,};
 591                 if( activate ){
 592                         snprintf(return_char,510,"%s,fail,%s", (char*)_D_APP_ACTIVE_,app_ID ); // prevent defect
 593                 }
 594                 else {
 595                         snprintf(return_char,510,"%s,fail,%s", (char*)_D_APP_INACTIVE_,app_ID ); // prevent defect
 596                 }
 597                 QUEUE_sendto ( _D_SYNCML_DM_SERVICE_SOCKET_PATH , (void*) return_char , strlen(return_char) );
 598         }
 599
 600         return result ;  // 1(OK),0(FAIL)
 601 }*/
 602
 603 /*static int __return_pkgmgr_cb(pkg_request_id req_id, const char *pkg_type, const char *pkg_name, const char *key, const char *val, const void *pmsg, void *data)
 604 {
 605       LOGTRACE("return_cb req_id[%d] pkg_type[%s] pkg_name[%s] key[%s] val[%s]\n", req_id, pkg_type, pkg_name, key, val);
 606 //    printf("return_cb req_id[%d] pkg_type[%s] pkg_name[%s] key[%s] val[%s]\n", req_id, pkg_type, pkg_name, key, val);
 607
 608       if( strncmp(key, "end", strlen("end") ) == 0) {
 609                 snprintf(g_pkg_info.pkg_type, PKG_TYPE_STRING_LEN_MAX, "%s", pkg_type);
 610                 snprintf(g_pkg_info.pkg_name, PKG_NAME_STRING_LEN_MAX, "%s", pkg_name);
 611                 //snprintf(g_pkg_info.pkg_version, PKG_VERSION_STRING_LEN_MAX, "%s", val);
 612                 //exit(0); ==> exit ���� �׳� process ��ü�� �׾� ����..
 613                 ecore_main_loop_quit(); // ==> ecore_main_loop_begin() ���� �κ��� ����
 614                 //pthread_cond_signal(&wait_cond); // sending signal
 615       }
 616     else if( strncmp(key, "install_percent", strlen("install_percent") ) == 0) {
 617                 LOGTRACE("install_percent[%s] \n", val);
 618     }
 619       return 0; // Prevent defect 25315
 620 }*/
 621
 622 /*static int __get_mobile_tracker_status()
 623 {
 624         char str_key_name[128] = { 0, };
 625         int int_key = 0;
 626
 627         memset(str_key_name, 0, sizeof(str_key_name));
 628         snprintf(str_key_name, sizeof(str_key_name), "%s", VCONFKEY_SETAPPL_STATE_MOBILE_TRACKER_BOOL); //db/setting/mobile_tracker
 629
 630         if (!vconf_get_bool(str_key_name, &int_key)) {
 631                 _DEBUG_VERBOSE("%s success , int_key : %d \n", VCONFKEY_SETAPPL_STATE_MOBILE_TRACKER_BOOL, int_key);
 632         } else {
 633                 _DEBUG_VERBOSE("%s failed \n", VCONFKEY_SETAPPL_STATE_MOBILE_TRACKER_BOOL);
 634         }
 635
 636         _DEBUG_VERBOSE(" %s vconf %d value \n", VCONFKEY_SETAPPL_STATE_MOBILE_TRACKER_BOOL, int_key);
 637         return int_key;
 638 }*/