src/plugins/dm-private/lawmo/src/plugin_interface.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 <stdlib.h>
  19 #include <string.h>
  20 #include <stdio.h>
  21 #include <unistd.h>
  22 #include <glib.h>
  23 #include <glib/gprintf.h>
  24 #include <vconf.h>
  25
  26 /*sync-agent*/
  27 #include <sync_agent.h>
  28
  29 #include "plugin_devexe_error.h"
  30
  31 #ifndef EXPORT_API
  32 #define EXPORT_API __attribute__ ((visibility("default")))
  33 #endif
  34
  35 #ifndef OMADM_AGENT_LOG
  36 #undef LOG_TAG
  37 #define LOG_TAG "PLUGIN_LAWMO"
  38 #endif
  39
  40 #define SERVER_NUM                                                                                                              1
  41
  42 #define ROOT    "./Ext/OSPS"
  43
  44 typedef enum {
  45         FULLY_LOCK,
  46         PARTAILLY_LOCK,
  47         UNLOCK,
  48         FACTORY_RESET,
  49         WIPE,
  50
  51         RING_START,
  52         RING_STOP,
  53
  54         MT_LOCATION,
  55         MT_STOP,
  56         MT_TRACKING,
  57
  58         FW_DIVERTREQUEST,
  59
  60         MK_LOCK
  61 } lawmo_ext_name_e;
  62
  63 typedef int (*Execute_Device) (int plugin_name, ...);
  64 typedef struct {
  65         lawmo_ext_name_e ext_name;
  66         char *main_path;        /* path except to root path */
  67         Execute_Device func_execute_device;
  68 } ext_function_s;
  69
  70 static sync_agent_dev_return_e _fully_lock(int platform, int *err_num, int check_operation);
  71 static sync_agent_dev_return_e _partially_lock(int platform, int *err_num, int check_operation);
  72 static sync_agent_dev_return_e _unlock(int platform, int *err_num, int check_operation);
  73 static sync_agent_dev_return_e _factory_reset(int platform, int *err_num, int check_operation);
  74 static sync_agent_dev_return_e _remote_wipe(int platform, int *err_num, int check_operation);
  75 static sync_agent_dev_return_e _ring_my_phone_start(int platform, int *err_num, int check_operation);
  76 static sync_agent_dev_return_e _ring_my_phone_stop(int platform, int *err_num, int check_operation);
  77 static sync_agent_dev_return_e _mobile_tracking_get_location(int platform, int *err_num, int check_operation);
  78 static sync_agent_dev_return_e _mobile_tracking_operation_stop(int platform, int *err_num, int check_operation);
  79 static sync_agent_dev_return_e _mobile_tracking_operation(int platform, int *err_num, int check_operation);
  80 static sync_agent_dev_return_e _forwarding_diver_request(int platform, int *err_num, int check_operation);
  81 static sync_agent_dev_return_e _master_key_lock_release(int platform, int *err_num, int check_operation);
  82
  83 static ext_function_s ext_functions[] = {
  84
  85         /* Lock & Wipe */
  86         {FULLY_LOCK, "LAWMO/OSP/Operations/FullyLock", (Execute_Device) _fully_lock},
  87         {PARTAILLY_LOCK, "LAWMO/OSP/Operations/PartiallyLock", (Execute_Device) _partially_lock},
  88         {UNLOCK, "LAWMO/OSP/Operations/UnLock", (Execute_Device) _unlock},
  89         {FACTORY_RESET, "LAWMO/OSP/Operations/FactoryReset", (Execute_Device) _factory_reset},
  90         {WIPE, "LAWMO/OSP/Operations/Wipe", (Execute_Device) _remote_wipe},
  91         /* TODO : should add the lock&wipe interface */
  92
  93         /* Ring My Phone */
  94         /* TODO */
  95         {RING_START, "LAWMO/OSP/Ext/RingMyPhone/Operations/Start", (Execute_Device) _ring_my_phone_start},
  96         {RING_STOP, "LAWMO/OSP/Ext/RingMyPhone/Operations/Stop", (Execute_Device) _ring_my_phone_stop},
  97
  98         /* Location */
  99         /* TODO */
 100         {MT_LOCATION, "MobileTraking/Operation/Get/Location", (Execute_Device) _mobile_tracking_get_location},
 101         {MT_STOP, "MobileTracking/Operations/Stop", (Execute_Device) _mobile_tracking_operation_stop},
 102         {MT_TRACKING, "MobileTracking/Operations/Tracking", (Execute_Device) _mobile_tracking_operation},
 103
 104         /* Forwarding */
 105         /* TODO */
 106         {FW_DIVERTREQUEST, "Forwarding/Operations/DivertRequest", (Execute_Device) _forwarding_diver_request},
 107
 108         /* MasterKey */
 109         /* TODO */
 110         {MK_LOCK, "MasterKey/Operations/LockRelease", (Execute_Device) _master_key_lock_release},
 111
 112         {0, 0}                  /* end array */
 113 };
 114
 115 static sync_agent_get_devinfo_cb func_get_dev_Info = 0;
 116
 117 /* static function */
 118 static char *_get_main_path(const char *mo_path);
 119
 120 //static int _get_index(const char *name);
 121 //static char *_get_mo_value_str(const char *vconf_key, int n_index);
 122
 123 EXPORT_API char **sync_agent_plugin_get_server_id_list(int *server_id_list_cnt)
 124 {
 125         _EXTERN_FUNC_ENTER;
 126 /*
 127         *server_id_list_cnt = 0;
 128         char **temp_id_list = (char **)calloc(SERVER_NUM, sizeof(char *));
 129         if (temp_id_list == NULL) {
 130                 _EXTERN_FUNC_EXIT;
 131                 return 0;
 132         }
 133
 134         char *sever_name = 0;
 135         int server_idx = 0;
 136         char *server_id = 0;
 137
 138         int i;
 139         for (i = 0; i < SERVER_NUM; i++) {
 140
 141                 switch (i) {
 142                 case 0:
 143                         sever_name = ALTER_SYNCMLDM_ACCNAME_1;
 144                         break;
 145                 case 1:
 146                         sever_name = ALTER_SYNCMLDM_ACCNAME_2;
 147                         break;
 148                 }
 149
 150                 server_idx = _get_index(sever_name);
 151                 server_id = _get_mo_value_str(CSC_VCONF_KEY_SYNCMLDM_SERVID, server_idx);
 152                 if (server_id == NULL) {
 153                         switch(i){
 154                         case 0:
 155                                 server_id = strdup(ALTER_SYNCMLDM_SERVID_1);
 156                                 break;
 157                         case 1:
 158                                 server_id = strdup(ALTER_SYNCMLDM_SERVID_2);
 159                                 break;
 160                         }
 161                 }
 162                 _DEBUG_INFO("Temp_id_list[%d] = %s\n", i, server_id);
 163                 temp_id_list[i] = server_id;
 164                 (*server_id_list_cnt)++;
 165         }
 166         _DEBUG_INFO("server_id_list_cnt = %d\n", *server_id_list_cnt);
 167
 168         _EXTERN_FUNC_EXIT;
 169         return temp_id_list;
 170 */
 171         *server_id_list_cnt = 1;
 172         char **temp_id_list = (char **)calloc(SERVER_NUM, sizeof(char *));
 173         if (temp_id_list == NULL) {
 174                 _EXTERN_FUNC_EXIT;
 175                 return NULL;
 176         }
 177         char *server_id = NULL;
 178         server_id = strdup("*");
 179         *temp_id_list = server_id;
 180
 181         _DEBUG_INFO("lawmo  server_id = %s\n", server_id);
 182         _DEBUG_INFO("lawmo  server_id_list_cnt = %d\n", *server_id_list_cnt);
 183
 184         _EXTERN_FUNC_EXIT;
 185         return temp_id_list;
 186 }
 187
 188 EXPORT_API int sync_agent_plugin_get_mo_value(const char *mo_pull_path, const char *mo_name, char **mo_value)
 189 {
 190         _EXTERN_FUNC_ENTER;
 191
 192         _DEBUG_INFO("mo_name : %s", mo_name);
 193         *mo_value = 0;
 194
 195         if (mo_pull_path == NULL || mo_name == NULL) {
 196                 return -1;
 197         }
 198
 199         _DEBUG_INFO("mo_value : %s", *mo_value);
 200
 201         _EXTERN_FUNC_EXIT;
 202         return 0;
 203 }
 204
 205 EXPORT_API void sync_agent_plugin_set_function_get_devinfo(sync_agent_get_devinfo_cb func)
 206 {
 207         _EXTERN_FUNC_ENTER;
 208
 209         func_get_dev_Info = func;
 210
 211         _EXTERN_FUNC_EXIT;
 212 }
 213
 214 EXPORT_API int sync_agent_plugin_initialize()
 215 {
 216         _EXTERN_FUNC_ENTER;
 217
 218         int result = 0;
 219         result = 0; //req_fmm_server_reg(NULL);
 220         /*
 221         if (result != 0) {
 222                 goto error;
 223         }
 224         */
 225         _EXTERN_FUNC_EXIT;
 226         return 1;
 227 /*
 228  error:
 229         _EXTERN_FUNC_EXIT;
 230         return -1;              // Fail
 231 */
 232 }
 233
 234 EXPORT_API int sync_agent_plugin_execute_ext(const char *mo_path, int *err_num, int check_operation)
 235 {
 236         _EXTERN_FUNC_ENTER;
 237
 238         if (mo_path == NULL) {
 239                 _DEBUG_INFO("mo_path is NULL\n");
 240                 _EXTERN_FUNC_EXIT;
 241                 return 0;
 242         }
 243         _DEBUG_INFO("mo_path = %s\n", mo_path);
 244
 245         char *main_path = _get_main_path(mo_path);
 246         if (main_path == NULL) {
 247                 _DEBUG_INFO("main_path is NULL\n");
 248                 _EXTERN_FUNC_EXIT;
 249                 return 0;
 250         }
 251         _DEBUG_INFO("main_path = %s\n", main_path);
 252
 253         int ret = 1;
 254         int slp_exe_ret = 1;
 255
 256         int i = 0;
 257         while (ext_functions[i].main_path != 0 && ext_functions[i].func_execute_device != 0) {
 258                 _DEBUG_INFO("oper 1 %s", main_path);
 259                 _DEBUG_INFO("oper 2 %s", ext_functions[i].main_path);
 260                 if (strcmp(main_path, ext_functions[i].main_path) == 0) {
 261                         _DEBUG_INFO("%s Part", main_path);
 262
 263                         slp_exe_ret = ext_functions[i].func_execute_device(1, err_num, check_operation);
 264                         _DEBUG_INFO("execute return : %d", slp_exe_ret);
 265
 266                         if (slp_exe_ret != SYNC_AGENT_DEV_RETURN_SUCCESS) {
 267                                 ret = 0;
 268                                 _DEBUG_INFO("--------------------------------------lawmo operation fail : %d---------------------------------\n", (*err_num));
 269                         } else {
 270                                 //*err_num = __convert_errcode(ext_functions[i].ext_name, slp_exe_ret);
 271                                 _DEBUG_INFO("--------------------------------------lawmo result value : %d---------------------------------\n", (*err_num));
 272                         }
 273                         break;
 274                 } else {
 275                         _DEBUG_INFO("--------------------------------------not search lawmo operation---------------------------------\n");
 276                 }
 277                 i++;
 278         }
 279
 280         if (main_path != NULL)
 281                 free(main_path);
 282
 283         _EXTERN_FUNC_EXIT;
 284         return ret;
 285 }
 286
 287 static char *_get_main_path(const char *mo_path)
 288 {
 289         _INNER_FUNC_ENTER;
 290
 291         int root_length = strlen(ROOT);
 292         int mo_path_length = strlen(mo_path);
 293
 294         char *main_path = 0;
 295
 296         char *ptr = strstr(mo_path, ROOT);
 297         if (ptr != NULL && root_length < mo_path_length) {
 298                 _DEBUG_TRACE("%s Search Success !!\n", ROOT);
 299                 main_path = g_strdup_printf("%s", mo_path + (root_length + 1));
 300         }
 301
 302         _INNER_FUNC_EXIT;
 303
 304         return main_path;
 305 }
 306
 307 /*
 308 static int _get_index(const char *name)
 309 {
 310         _INNER_FUNC_ENTER;
 311
 312         if (name == NULL) {
 313                 return -1;
 314         }
 315
 316         int n_acc_count = 0;
 317         if (vconf_get_int(CSC_VCONF_KEY_SYNCMLDM_NBFIELD, &n_acc_count)) {
 318                 _DEBUG_TRACE("vconf_get_int FAIL");
 319                 //return -1;
 320                 n_acc_count =ALTER_SYNCMLDM_NBFIELD;
 321         }
 322
 323         _DEBUG_TRACE("nAccCount : %d", n_acc_count);
 324
 325         int i = 0;
 326         for (; i < n_acc_count; i++) {
 327                 char *compare_name = _get_mo_value_str(CSC_VCONF_KEY_SYNCMLDM_ACCNAME, i + 1);
 328                 if (compare_name == NULL) {
 329                         switch(i) {
 330                         case 0:
 331                                 compare_name = ALTER_SYNCMLDM_ACCNAME_1;
 332                                 break;
 333                         case 1:
 334                                 compare_name = ALTER_SYNCMLDM_ACCNAME_2;
 335                                 break;
 336                         default :
 337                                 continue;
 338                                 break;
 339                         }
 340                 }
 341                 _DEBUG_TRACE("[%d] compare_name : %s [%d], name : %s [%d]", i, compare_name, strlen(compare_name), name, strlen(name));
 342                 if (!strcmp(name, compare_name)) {
 343                         _DEBUG_TRACE("nIndex : %d", i + 1);
 344                         _INNER_FUNC_EXIT;
 345                         return i + 1;
 346                 }
 347         }
 348
 349         _INNER_FUNC_EXIT;
 350         return -1;
 351 }
 352
 353 static char *_get_mo_value_str(const char *vconf_key, int n_index)
 354 {
 355         _INNER_FUNC_ENTER;
 356
 357         if (n_index == -1) {
 358                 _INNER_FUNC_EXIT;
 359                 return 0;
 360         }
 361
 362         char input_vconf_path[200] = { 0, };
 363         char rec_idx[8];
 364
 365         memset(rec_idx, 0x0, sizeof(rec_idx));
 366         snprintf(rec_idx, sizeof(rec_idx), "%d", n_index);
 367         snprintf(input_vconf_path, strlen(vconf_key) + strlen(rec_idx) + 1, vconf_key, n_index);
 368
 369         char *value = vconf_get_str(input_vconf_path);
 370         if (value == NULL) {
 371                 _DEBUG_TRACE("vconf_get_str FAIL");
 372         }
 373
 374         _INNER_FUNC_EXIT;
 375
 376         return value;
 377 }
 378 */
 379
 380 static sync_agent_dev_return_e _fully_lock(int platform, int *err_num, int check_operation)
 381 {
 382         _INNER_FUNC_ENTER;
 383
 384         /* AMT OFF */
 385         _DEBUG_TRACE("====================Fully_Lock==================== \n");
 386         _DEBUG_TRACE("check_operarion [%d]\n", check_operation);
 387
 388         int return_value;
 389
 390         if (check_operation == 1) {
 391                 _DEBUG_TRACE("checked : 1 =======return 202 =======\n");
 392                 *err_num = 202;
 393         } else {
 394
 395                 return_value = EXE_SUCCESS; //exec_fully_lock();
 396                 _DEBUG_TRACE("checked : 0 =======return :%d =======\n", return_value);
 397                 /*
 398                 if (return_value == EXE_SUCCESS) {
 399                         *err_num = OPERATION_SUCCEEDED;
 400                 } else {
 401                         *err_num = CLIENT_ERROR;
 402                 }
 403                 */
 404         }
 405
 406         _INNER_FUNC_EXIT;
 407         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 408
 409 }
 410
 411 static sync_agent_dev_return_e _partially_lock(int platform, int *err_num, int check_operation)
 412 {
 413         _INNER_FUNC_ENTER;
 414
 415         /* AMT OFF */
 416         _DEBUG_TRACE("====================Partially_Lock==================== \n");
 417         sleep(3);
 418         int return_value = OPERATION_SUCCEEDED;
 419         /*
 420            return PARTIALLY_LOCK_DEVICE_FAILED;
 421            sync_agent_execute_dev_function(2, "partial_lock", 0);
 422            vconf_get_bool(VCONFKEY_SETAPPL_FIND_MY_MOBILE_REMOTE_CONTROL_BOOL, &rc_status));
 423            if(true)
 424            return_value = 1200;
 425            else
 426            return_value = 1452;
 427          */
 428         *err_num = return_value;
 429
 430         _INNER_FUNC_EXIT;
 431         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 432 }
 433
 434 static sync_agent_dev_return_e _unlock(int platform, int *err_num, int check_operation)
 435 {
 436         _INNER_FUNC_ENTER;
 437
 438         /* AMT OFF */
 439         _DEBUG_TRACE("====================UnLock==================== \n");
 440         _DEBUG_TRACE("check_operarion [%d]\n", check_operation);
 441
 442         int return_value = OPERATION_SUCCEEDED;
 443
 444         *err_num = return_value;
 445
 446         _INNER_FUNC_EXIT;
 447         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 448 }
 449
 450 static sync_agent_dev_return_e _factory_reset(int platform, int *err_num, int check_operation)
 451 {
 452         _INNER_FUNC_ENTER;
 453
 454         /* AMT OFF */
 455         _DEBUG_TRACE("====================Factory_Reset==================== \n");
 456         int return_value = OPERATION_SUCCEEDED;
 457         sleep(3);
 458         /*
 459            vconf_get_bool(VCONFKEY_SETAPPL_FIND_MY_MOBILE_REMOTE_CONTROL_BOOL, &rc_status));
 460            if(true)
 461            return_value = 1200;
 462            else
 463            return_value = 1452;
 464          */
 465         *err_num = return_value;
 466
 467         _INNER_FUNC_EXIT;
 468         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 469 }
 470
 471 static sync_agent_dev_return_e _remote_wipe(int platform, int *err_num, int check_operation)
 472 {
 473         _INNER_FUNC_ENTER;
 474         /* AMT OFF */
 475         _DEBUG_TRACE("====================Remote_Wipe==================== \n");
 476
 477         int return_value = 202;
 478         if (check_operation == 1) {
 479                 /*
 480                    vconf_get_bool(VCONFKEY_SETAPPL_FIND_MY_MOBILE_REMOTE_CONTROL_BOOL, &rc_status));
 481                    if(true)
 482                    return_value = 202;
 483                    else
 484                    return_value = 1452;
 485                  */
 486                 *err_num = return_value;
 487         } else {
 488                 return_value = OPERATION_SUCCEEDED; //exec_wipe_out();
 489                 g_printf("checked : 0 =======return :%d =======\n", return_value);
 490                 *err_num = return_value;
 491         }
 492         /*
 493            sync_agent_execute_dev_function(2, "factory_reset", 0);
 494            return WIPE_OPERATION_NOT_PERFORMED;
 495            return  WIPE_DEVICES_DATA_FAILED;
 496            return EXTERNAL_AND_SIM_MEMORY_WIPE_FAILED;
 497            return EXTERNAL_MEMORY_WIPE_FAILED;
 498            return SIM_MEMORY_WIPE_FAILED;
 499          */
 500         _INNER_FUNC_EXIT;
 501         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 502 }
 503
 504 static sync_agent_dev_return_e _ring_my_phone_start(int platform, int *err_num, int check_operation)
 505 {
 506         _INNER_FUNC_EXIT;
 507
 508         /* AMT OFF */
 509         _DEBUG_TRACE("====================Ring my phone start==================== \n");
 510         _DEBUG_TRACE("check_operarion [%d]\n", check_operation);
 511
 512         int return_value;
 513
 514         if (check_operation == 1) {
 515                 /*
 516                    vconf_get_bool(VCONFKEY_SETAPPL_FIND_MY_MOBILE_REMOTE_CONTROL_BOOL, &rc_status));
 517                    if(true)
 518                    return_value = 1200;
 519                    else
 520                    return_value = 1452;
 521                  */
 522                 *err_num = OPERATION_SUCCEEDED;
 523
 524         } else {
 525                 return_value = EXE_SUCCESS; // exec_ring_start();
 526                 _DEBUG_TRACE("checked : 0 =======return :%d =======\n", return_value);
 527                 /*
 528                 if (return_value == EXE_SUCCESS) {
 529                         *err_num = OPERATION_SUCCEEDED;
 530                 } else {
 531                         *err_num = AMT_STATUS_OFF;
 532                 }
 533                 */
 534         }
 535
 536         _INNER_FUNC_EXIT;
 537         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 538 }
 539
 540 static sync_agent_dev_return_e _ring_my_phone_stop(int platform, int *err_num, int check_operation)
 541 {
 542         _INNER_FUNC_ENTER;
 543         /* AMT OFF */
 544         _DEBUG_TRACE("====================Ring my phone stop====================\n");
 545         _DEBUG_TRACE("check_operarion [%d]\n", check_operation);
 546
 547         int return_value = 202;
 548         sleep(3);
 549
 550         if (check_operation == 1) {
 551                 *err_num = return_value;
 552         } else {
 553
 554                 return_value = EXE_SUCCESS; //exec_ring_stop();
 555                 /*
 556                 if (return_value == EXE_SUCCESS) {
 557                         *err_num = OPERATION_SUCCEEDED;
 558                 } else {
 559                         *err_num = OPERATION_SUCCEEDED;
 560                 }
 561                 */
 562         }
 563
 564         _INNER_FUNC_EXIT;
 565         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 566 }
 567
 568 static sync_agent_dev_return_e _mobile_tracking_get_location(int platform, int *err_num, int check_operation)
 569 {
 570         _INNER_FUNC_ENTER;
 571
 572         /* AMT OFF */
 573         _DEBUG_TRACE("====================MobileTracking_Get_Location====================\n");
 574         sleep(3);
 575         int return_value = 202;
 576         if (check_operation == 1) {
 577                 /*
 578                    vconf_get_bool(VCONFKEY_SETAPPL_FIND_MY_MOBILE_REMOTE_CONTROL_BOOL, &rc_status));
 579                    if(true)
 580                    return_value = 202;
 581                    else
 582                    return_value = 1452;
 583                  */
 584                 _DEBUG_TRACE("checked : 1 =======return 202 =======\n");
 585                 *err_num = return_value;
 586         } else {
 587                 return_value = OPERATION_SUCCEEDED; // exec_location();
 588                 _DEBUG_TRACE("checked : 0 =======return :%d =======\n", return_value);
 589                 *err_num = return_value;
 590         }
 591
 592         _INNER_FUNC_EXIT;
 593         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 594 }
 595
 596 static sync_agent_dev_return_e _mobile_tracking_operation_stop(int platform, int *err_num, int check_operation)
 597 {
 598         _INNER_FUNC_ENTER;
 599
 600         /* AMT OFF */
 601         _DEBUG_TRACE("====================MobileTracking_Operation_Stop====================\n");
 602         sleep(3);
 603
 604         *err_num = OPERATION_SUCCEEDED;
 605
 606         _INNER_FUNC_EXIT;
 607         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 608 }
 609
 610 static sync_agent_dev_return_e _mobile_tracking_operation(int platform, int *err_num, int check_operation)
 611 {
 612         _INNER_FUNC_ENTER;
 613         /* AMT OFF */
 614         _DEBUG_TRACE("====================MobileTracking_Operation====================\n");
 615         sleep(3);
 616         int return_value = 202;
 617         if (check_operation == 1) {
 618                 *err_num = return_value;
 619         } else {
 620                 *err_num = OPERATION_SUCCEEDED;
 621         }
 622
 623         _INNER_FUNC_EXIT;
 624         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 625
 626 }
 627
 628 static sync_agent_dev_return_e _forwarding_diver_request(int platform, int *err_num, int check_operation)
 629 {
 630         _INNER_FUNC_ENTER;
 631
 632         /* AMT OFF */
 633         _DEBUG_TRACE("====================Forwarding_DiverRequest====================\n");
 634         int return_value = 202;
 635         if (check_operation == 1) {
 636                 /*
 637                    vconf_get_bool(VCONFKEY_SETAPPL_FIND_MY_MOBILE_REMOTE_CONTROL_BOOL, &rc_status));
 638                    if(true)
 639                    return_value = 202;
 640                    else
 641                    return_value = 1452;
 642                  */
 643                 //return return_value;
 644                 *err_num = return_value;
 645         } else {
 646                 return_value = OPERATION_SUCCEEDED; // exec_call_forwarding();
 647                 _DEBUG_TRACE("checked : 0 =======return :%d =======\n", return_value);
 648                 *err_num = return_value;
 649         }
 650         /*
 651            return CALL_AND_SMS_FORWARDING_FAILED;
 652            return CALL_FORWARDING_FAILED;
 653            return SMS_FORWARDING_FAILED;
 654          */
 655         //return return_value;
 656
 657         _INNER_FUNC_EXIT;
 658         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 659
 660 }
 661
 662 static sync_agent_dev_return_e _master_key_lock_release(int platform, int *err_num, int check_operation)
 663 {
 664         _INNER_FUNC_ENTER;
 665         /* AMT OFF */
 666         _DEBUG_TRACE("====================MasterKey_LockRelease====================\n");
 667         _DEBUG_TRACE("check_operarion [%d]\n", check_operation);
 668         int return_value = 202;
 669         /* for test */
 670
 671         if (check_operation == 1) {
 672                 *err_num = return_value;
 673         } else {
 674
 675                 return_value =  EXE_SUCCESS; //exec_unlock_lock();
 676                 /*
 677                 if (return_value == EXE_SUCCESS) {
 678                         *err_num = OPERATION_SUCCEEDED;
 679                 } else {
 680                         *err_num = OPERATION_SUCCEEDED;
 681                 }
 682                 */
 683         }
 684
 685         _INNER_FUNC_EXIT;
 686         return SYNC_AGENT_DEV_RETURN_SUCCESS;
 687 }