setting-password/src/setting-password.c

   1 /*
   2  * setting
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd.
   5  *
   6  * Contact: MyoungJune Park <mj2004.park@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21 #include <setting-password.h>
  22 #include <security-server.h>
  23
  24 #ifdef SUPPORT_MDM
  25 #include <Ecore_X.h>
  26 #include <utilX.h>
  27 #endif
  28
  29 #ifndef UG_MODULE_API
  30 #define UG_MODULE_API __attribute__ ((visibility("default")))
  31 #endif
  32
  33 static struct _pw_item pw_its[] = {
  34         { SETTING_PW_TYPE_PASSWORD, "SETTING_PW_TYPE_PASSWORD" },
  35         { SETTING_PW_TYPE_SET_PASSWORD, "SETTING_PW_TYPE_SET_PASSWORD" },
  36         { SETTING_PW_TYPE_CHANGE_PASSWORD, "SETTING_PW_TYPE_CHANGE_PASSWORD" },
  37         { SETTING_PW_TYPE_SIMPLE_PASSWORD, "SETTING_PW_TYPE_SIMPLE_PASSWORD" },
  38         { SETTING_PW_TYPE_SET_SIMPLE_PASSWORD, "SETTING_PW_TYPE_SET_SIMPLE_PASSWORD" },
  39         { SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD, "SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD" },
  40         { SETTING_PW_TYPE_ENTER_LOCK_TYPE, "SETTING_PW_TYPE_ENTER_LOCK_TYPE" },
  41         { SETTING_PW_TYPE_SIM_LOCK_ON, "SETTING_PW_TYPE_SIM_LOCK_ON" },
  42         { SETTING_PW_TYPE_SIM_LOCK_OFF, "SETTING_PW_TYPE_SIM_LOCK_OFF" },
  43         { SETTING_PW_TYPE_PIN_LOCK_ON, "SETTING_PW_TYPE_PIN_LOCK_ON" },
  44         { SETTING_PW_TYPE_PIN_LOCK_OFF, "SETTING_PW_TYPE_PIN_LOCK_OFF" },
  45         { SETTING_PW_TYPE_CHANGE_PIN1, "SETTING_PW_TYPE_CHANGE_PIN1" },
  46         { SETTING_PW_TYPE_CHANGE_PIN2, "SETTING_PW_TYPE_CHANGE_PIN2" },
  47         { SETTING_PW_TYPE_PIN1_BLOCKED, "SETTING_PW_TYPE_PIN1_BLOCKED" },
  48         { SETTING_PW_TYPE_PIN2_BLOCKED, "SETTING_PW_TYPE_PIN2_BLOCKED" },
  49         { SETTING_PW_TYPE_RESET, "SETTING_PW_TYPE_RESET" },
  50 #ifdef SUPPORT_MDM
  51         { SETTING_PW_TYPE_MDM_NEW_POLICY, "SETTING_PW_TYPE_MDM_NEW_POLICY" }, /*for mdm policy */
  52         { SETTING_PW_TYPE_MDM_CHANGE_PASSWORD, "SETTING_PW_TYPE_MDM_CHANGE_PASSWORD" },
  53         { SETTING_PW_TYPE_MDM_TO_SIMPLE, "SETTING_PW_TYPE_MDM_TO_SIMPLE" },
  54 #endif
  55         { SETTING_PW_TYPE_MAX, NULL }
  56 };
  57
  58 static void setting_tapi_init(SettingPasswordUG *ad);
  59 static void setting_password_ug_display_result_popup(tapi_receive_info *result, SettingPasswordUG *ad);
  60
  61 static void setting_password_ug_cb_resize(void *data, Evas *e, Evas_Object *obj, void *event_info)
  62 {
  63         SettingPasswordUG *ad = (SettingPasswordUG *) data;
  64         setting_view_update(&setting_view_password_main, ad);
  65 }
  66
  67 static void setting_tapi_init(SettingPasswordUG *ad)
  68 {
  69         SETTING_TRACE_BEGIN;
  70         switch (ad->view_type) {
  71         case SETTING_PW_TYPE_SIM_LOCK_ON:
  72         case SETTING_PW_TYPE_SIM_LOCK_OFF:
  73         case SETTING_PW_TYPE_PIN_LOCK_ON:
  74         case SETTING_PW_TYPE_PIN_LOCK_OFF:
  75         case SETTING_PW_TYPE_CHANGE_PIN1:
  76         case SETTING_PW_TYPE_CHANGE_PIN2:
  77         case SETTING_PW_TYPE_PIN1_BLOCKED:
  78         case SETTING_PW_TYPE_PIN2_BLOCKED:
  79                 ad->handle =  tel_init(NULL);
  80                 if (!ad->handle) {
  81                         SETTING_TRACE_DEBUG("%s*** [ERR] tel_init. ***%s",
  82                              SETTING_FONT_RED, SETTING_FONT_BLACK);
  83                         setting_password_ug_create_popup_notitle_nobtn(ad,
  84                                                                        _("IDS_COM_POP_ERROR"),
  85                                                                        FALSE);
  86                 }
  87
  88                 break;
  89         default:
  90                 break;
  91         }
  92         SETTING_TRACE_END;
  93 }
  94
  95 static void setting_tapi_finize(SettingPasswordUG *ad)
  96 {
  97         SETTING_TRACE_BEGIN;
  98         switch (ad->view_type) {
  99         case SETTING_PW_TYPE_SIM_LOCK_ON:
 100         case SETTING_PW_TYPE_SIM_LOCK_OFF:
 101         case SETTING_PW_TYPE_PIN_LOCK_ON:
 102         case SETTING_PW_TYPE_PIN_LOCK_OFF:
 103         case SETTING_PW_TYPE_CHANGE_PIN1:
 104         case SETTING_PW_TYPE_CHANGE_PIN2:
 105         case SETTING_PW_TYPE_PIN1_BLOCKED:
 106         case SETTING_PW_TYPE_PIN2_BLOCKED:
 107                 if (tel_deinit(ad->handle) != TAPI_API_SUCCESS) {
 108                         SETTING_TRACE_DEBUG
 109                             ("%s*** [ERR] setting_network_unsubscribe_tapi_events. ***%s",
 110                              SETTING_FONT_RED, SETTING_FONT_BLACK);
 111                         setting_password_ug_create_popup_notitle_nobtn(ad,
 112                                                                        _("IDS_COM_POP_ERROR"),
 113                                                                        FALSE);
 114                 }
 115                 break;
 116         default:
 117                 break;
 118         }
 119         SETTING_TRACE_END;
 120 }
 121
 122 setting_pw_type __get_password_view_type(SettingPasswordUG *ad, service_h service)
 123 {
 124         SETTING_TRACE_BEGIN;
 125
 126         service_get_extra_data(service, "viewtype", &(ad->view_type_string));
 127         service_get_extra_data(service, "current", &(ad->cur_pwd));
 128
 129         if(ad->cur_pwd)
 130                 SETTING_TRACE_DEBUG("Receive current : %s", ad->cur_pwd);
 131 #ifdef SUPPORT_MDM
 132         char *status = NULL;
 133         service_get_extra_data(service, "status", &status);
 134         if(safeStrCmp(status, "expired") == 0)
 135         {
 136                 ad->is_expired = SETTING_PW_STATUS_EXPIRED;
 137         }
 138         else
 139         {
 140                 ad->is_expired = SETTING_PW_STATUS_OK;
 141         }
 142         SETTING_TRACE_DEBUG("is_expired : %d", ad->is_expired);
 143 #endif
 144         SETTING_TRACE("viewtype:%s", ad->view_type_string);
 145         setting_pw_type ret_pw_type = 0;
 146         int i;
 147
 148         for(i = 0; i < SETTING_PW_TYPE_MAX; i++)
 149         {
 150                 if (0 == safeStrCmp(ad->view_type_string, pw_its[i].pw_type_string))
 151                 {
 152                         ret_pw_type = pw_its[i].pw_type_num;
 153                         break;
 154                 }
 155         }
 156
 157         ad->is_empty = setting_password_is_password_empty();
 158
 159         /* exception handle */
 160         if(ret_pw_type == SETTING_PW_TYPE_PASSWORD)
 161         {
 162                 ret_pw_type = SETTING_PW_TYPE_SET_PASSWORD;
 163         }
 164         else if(ret_pw_type == SETTING_PW_TYPE_SIMPLE_PASSWORD)
 165         {
 166                 ret_pw_type = SETTING_PW_TYPE_SET_SIMPLE_PASSWORD;
 167         }
 168         else if(ret_pw_type == SETTING_PW_TYPE_CHANGE_PASSWORD)
 169         {
 170                 if(ad->is_empty == TRUE)
 171                 {
 172                         ret_pw_type = SETTING_PW_TYPE_SET_PASSWORD;
 173                 }
 174         }
 175         else if(ret_pw_type == SETTING_PW_TYPE_CHANGE_SIMPLE_PASSWORD)
 176         {
 177                 if(ad->is_empty == TRUE)
 178                 {
 179                         ret_pw_type = SETTING_PW_TYPE_SET_SIMPLE_PASSWORD;
 180                 }
 181         }
 182         else if( ret_pw_type == SETTING_PW_TYPE_RESET )
 183         {
 184                 if(ad->is_empty == TRUE)
 185                 {
 186                         /* To do : check screen lock option key */
 187                         if(ad->screen_lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD)
 188                                 ret_pw_type = SETTING_PW_TYPE_SET_PASSWORD;
 189                         else if(ad->screen_lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 190                                 ret_pw_type = SETTING_PW_TYPE_SET_SIMPLE_PASSWORD;
 191                 }
 192                 else
 193                 {
 194                         if(ad->screen_lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD)
 195                                 ret_pw_type = SETTING_PW_TYPE_PASSWORD;
 196                         else if(ad->screen_lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 197                                 ret_pw_type = SETTING_PW_TYPE_SIMPLE_PASSWORD;
 198                 }
 199         }
 200         else if( ret_pw_type == SETTING_PW_TYPE_ENTER_LOCK_TYPE )
 201         {
 202                 if(ad->screen_lock_type == SETTING_SCREEN_LOCK_TYPE_PASSWORD)
 203                                 ret_pw_type = SETTING_PW_TYPE_PASSWORD;
 204                 else if(ad->screen_lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD)
 205                                 ret_pw_type = SETTING_PW_TYPE_SIMPLE_PASSWORD;
 206         }
 207 #ifdef SUPPORT_MDM
 208         else if (ret_pw_type == SETTING_PW_TYPE_MDM_CHANGE_PASSWORD)
 209         {
 210                 if((ad->is_empty == TRUE)
 211                         || (ad->is_expired == SETTING_PW_STATUS_EXPIRED))
 212                 {
 213                         ret_pw_type = SETTING_PW_TYPE_MDM_NEW_POLICY;
 214                 }
 215         }
 216 #endif
 217         /* end */
 218
 219         return ret_pw_type;
 220 }
 221
 222 #if DISABLED_CODE
 223 static void setting_password_ug_set_password_cb(void *data, Evas_Object *obj,
 224                                                 void *event_info)
 225 {
 226         /* error check */
 227         retm_if(data == NULL, "Data parameter is NULL");
 228
 229         SettingPasswordUG *ad = (SettingPasswordUG *) data;
 230
 231         switch (btn_type(obj)) {
 232         case POPUP_RESPONSE_OK:
 233                 {
 234                         /*  creating a view. */
 235                         setting_view_create(&setting_view_password_main, (void *)ad);
 236                         evas_object_event_callback_add(ad->win_main_layout,
 237                                                        EVAS_CALLBACK_RESIZE,
 238                                                        setting_password_ug_cb_resize,
 239                                                        ad);
 240                         if (ad->setpw_notify)
 241                         {
 242                                 evas_object_del(ad->setpw_notify);
 243                                 ad->setpw_notify = NULL;
 244                         }
 245                 }
 246                 break;
 247
 248         case POPUP_RESPONSE_CANCEL:
 249                 {
 250                         if (ad->setpw_notify)
 251                         {
 252                                 evas_object_del(ad->setpw_notify);
 253                                 ad->setpw_notify = NULL;
 254                         }
 255
 256                         /* send result : Cancel */
 257                         service_h svc;
 258                         if(service_create(&svc))
 259                                 return;
 260
 261                         service_add_extra_data(svc, "result", "Cancel");
 262                         ug_send_result(ad->ug, svc);
 263                         SETTING_TRACE("Send Result : %s\n", "Cancel");
 264
 265                         service_destroy(svc);
 266
 267                         ug_destroy_me(ad->ug);
 268                 }
 269                 break;
 270         default:
 271                 break;
 272         }
 273 }
 274 #endif
 275 static char *__gl_err_desc_text_get(void *data, Evas_Object *obj, const char *part)
 276 {
 277         retv_if(data == NULL, NULL);
 278         char buf[256] = {0,};
 279
 280         snprintf(buf, sizeof(buf)-1, "<font color=#ff0000>%s</font>", (char*)data);
 281
 282         return strdup(buf);
 283 }
 284
 285 #ifdef SUPPORT_MDM
 286 void setting_password_ug_display_mdm_desc(void *data, const char* guide_text)
 287 {
 288         SETTING_TRACE_BEGIN;
 289         ret_if(data == NULL || guide_text == NULL);
 290
 291         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 292
 293         if(ad->mdm_desc != NULL)
 294         {
 295                 elm_object_item_del(ad->mdm_desc);
 296                 ad->mdm_desc = NULL;
 297         }
 298
 299         ad->guide_str = (char *)guide_text;
 300
 301         ad->mdm_desc = elm_genlist_item_append(ad->scroller, &(ad->itc_mdm_desc), ad, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 302
 303         SETTING_TRACE_END;
 304 }
 305
 306 static char *__gl_mdm_desc_text_get(void *data, Evas_Object *obj, const char *part)
 307 {
 308         SETTING_TRACE_BEGIN;
 309         retv_if(data == NULL, NULL);
 310         char buf[MAX_DESC_BUF_SIZE] = {0,};
 311
 312         SettingPasswordUG *ad = (SettingPasswordUG *)data;
 313
 314         if(ad->mdm_policy == NULL)
 315                 return NULL;
 316
 317         if(ad->guide_str)
 318                 safeCopyStr(buf, ad->guide_str, MAX_DESC_BUF_SIZE);
 319
 320         SETTING_TRACE_END;
 321         return strdup(buf);
 322 }
 323
 324 static Eina_Bool __setting_password_ug_keydown_cb(void *data, int type, void *event)
 325 {
 326         SETTING_TRACE_BEGIN;
 327
 328         Ecore_Event_Key *ev = event;
 329
 330         if(!strcmp(ev->keyname, KEY_END) || !strcmp(ev->keyname, KEY_SELECT))
 331         {
 332                 SETTING_TRACE_DEBUG("event key name : %s", ev->keyname);
 333                 // nothing to do.
 334         }
 335         return ECORE_CALLBACK_DONE;
 336 }
 337
 338 static void __setting_password_ug_key_grab(SettingPasswordUG *ad)
 339 {
 340         SETTING_TRACE_BEGIN;
 341         Ecore_X_Window xwin = 0;
 342         Ecore_X_Display *disp = NULL;
 343
 344         int ret = 0;
 345
 346         if(ad == NULL)
 347                 return;
 348
 349         disp = ecore_x_display_get();
 350         xwin = elm_win_xwindow_get((Evas_Object*)ug_get_window());
 351
 352         ret = utilx_grab_key(disp, xwin, KEY_SELECT, EXCLUSIVE_GRAB);
 353         if(ret)
 354                 return;
 355
 356         ad->event_handler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, __setting_password_ug_keydown_cb, ad);
 357         SETTING_TRACE_END;
 358 }
 359 static void __setting_password_ug_key_ungrab(SettingPasswordUG *ad)
 360 {
 361         SETTING_TRACE_BEGIN;
 362         Ecore_X_Window xwin = 0;
 363         Ecore_X_Display *disp = NULL;
 364
 365         int ret = 0;
 366
 367         if(ad == NULL)
 368                 return;
 369
 370         disp = ecore_x_display_get();
 371         xwin = elm_win_xwindow_get((Evas_Object*)ug_get_window());
 372
 373         ret = utilx_ungrab_key(disp, xwin, KEY_HOME);
 374         if(ret)
 375                 return;
 376
 377         ecore_event_handler_del(ad->event_handler);
 378 }
 379 #endif
 380
 381 static void *setting_password_ug_on_create(ui_gadget_h ug,
 382                                            enum ug_mode mode, service_h service,
 383                                            void *priv)
 384 {
 385         setting_retvm_if((!priv), NULL, "!priv");
 386
 387         SettingPasswordUG *passwordUG = (SettingPasswordUG *)priv;
 388         passwordUG->ug = ug;
 389         passwordUG->win_main_layout = (Evas_Object *) ug_get_parent_layout(ug);
 390         passwordUG->win_get = (Evas_Object *) ug_get_window();
 391         evas_object_show(passwordUG->win_main_layout);
 392         passwordUG->evas = evas_object_evas_get(passwordUG->win_main_layout);
 393
 394         setting_retvm_if(passwordUG->win_main_layout == NULL, NULL,
 395                          "cannot get main window ");
 396
 397         /* --------------------------------------------------------- */
 398         char *pa_path = NULL;;
 399
 400         pa_path = vconf_get_str(VCONFKEY_LANGSET);
 401         if (!pa_path) {
 402                 SETTING_TRACE
 403                     ("%s*** language setting has no proper value (nil) ***%s",
 404                      SETTING_FONT_BGREEN, SETTING_FONT_BLACK);
 405                 return NULL;
 406         }
 407         /* set launguage */
 408         setting_set_i18n(SETTING_PACKAGE, SETTING_LOCALEDIR);
 409         FREE(pa_path);
 410
 411         setting_create_Gendial_itc("dialogue/title", &(passwordUG->itc_title));
 412         setting_create_Gendial_itc("dialogue/1icon",&(passwordUG->itc_variable_height));
 413         passwordUG->itc_seperator.item_style = "dialogue/separator/21/with_line";
 414         passwordUG->itc_seperator.func.text_get = NULL;
 415         passwordUG->itc_seperator.func.content_get = NULL;
 416         passwordUG->itc_seperator.func.state_get = NULL;
 417         passwordUG->itc_seperator.func.del = NULL;
 418
 419         passwordUG->itc_err_desc.item_style = "multiline/1text";
 420         passwordUG->itc_err_desc.func.text_get = __gl_err_desc_text_get;
 421         passwordUG->itc_err_desc.func.content_get = NULL;
 422         passwordUG->itc_err_desc.func.state_get = NULL;
 423         passwordUG->itc_err_desc.func.del = NULL;
 424 #ifdef SUPPORT_MDM
 425         passwordUG->itc_mdm_desc.item_style = "multiline/1text";
 426         passwordUG->itc_mdm_desc.func.text_get = __gl_mdm_desc_text_get;
 427         passwordUG->itc_mdm_desc.func.content_get = NULL;
 428         passwordUG->itc_mdm_desc.func.state_get = NULL;
 429         passwordUG->itc_mdm_desc.func.del = NULL;
 430 #endif
 431
 432         /* get screen lock type */
 433         if( vconf_get_int(VCONFKEY_SETAPPL_SCREEN_LOCK_TYPE_INT, &(passwordUG->screen_lock_type)) < 0) {
 434                 passwordUG->screen_lock_type = 0;
 435         }
 436         SETTING_TRACE_DEBUG("screen lock type : %d", passwordUG->screen_lock_type);
 437
 438         passwordUG->cur_pwd = NULL;
 439
 440         /* init */
 441         passwordUG->view_type = __get_password_view_type(passwordUG, service);
 442         setting_tapi_init(passwordUG);
 443
 444 #ifdef SUPPORT_MDM
 445         /* To do : check for MDM server */
 446         passwordUG->mdm_data = NULL;
 447         passwordUG->mdm_policy = NULL;
 448
 449         passwordUG->mdm_status = mdm_get_service();
 450
 451         if(passwordUG->mdm_status == MDM_RESULT_SUCCESS)
 452         {
 453                 passwordUG->mdm_data = mdm_get_password_policy();
 454
 455                 passwordUG->mdm_policy = (mdm_password_policy_t*)(passwordUG->mdm_data->data);
 456
 457                 if ((SETTING_PW_TYPE_MDM_NEW_POLICY == passwordUG->view_type) /* support mdm policy */
 458                         || (SETTING_PW_TYPE_MDM_CHANGE_PASSWORD == passwordUG->view_type))
 459                 {
 460                         if(passwordUG->mdm_policy != NULL)
 461                         {
 462                                 if((passwordUG->mdm_policy->quality == MDM_PASSWORD_QUALITY_SOMETHING)
 463                                         || (passwordUG->mdm_policy->quality == MDM_PASSWORD_QUALITY_NUMERIC))
 464                                 {
 465                                         if( (passwordUG->view_type == SETTING_PW_TYPE_MDM_NEW_POLICY)
 466                                                 && (passwordUG->screen_lock_type == SETTING_SCREEN_LOCK_TYPE_SIMPLE_PASSWORD))
 467                                         {
 468                                                 /*if only length is 0~4, apply simple password mode */
 469                                                 if(passwordUG->mdm_policy->min_length <= SETTING_PW_UG_NORMAL_PASSWORD_MIN_LENGTH)
 470                                                 {
 471                                                         passwordUG->view_type = SETTING_PW_TYPE_MDM_TO_SIMPLE;
 472                                                 }
 473                                                 else
 474                                                 {
 475                                                         if(vconf_set_bool(VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, FALSE) != 0)
 476                                                         {
 477                                                                 SETTING_TRACE_DEBUG("[ERROR] setting VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL failed");
 478                                                         }
 479                                                 }
 480                                         }
 481                                 }
 482
 483                                 ecore_x_netwm_window_type_set(elm_win_xwindow_get(passwordUG->win_get), ECORE_X_WINDOW_TYPE_NOTIFICATION);
 484                                 utilx_set_system_notification_level(ecore_x_display_get(), elm_win_xwindow_get(passwordUG->win_get), UTILX_NOTIFICATION_LEVEL_NORMAL);
 485
 486                                 /*  creating a view. */
 487                                 setting_view_create(&setting_view_password_main,(void *)passwordUG);
 488                                 evas_object_event_callback_add(passwordUG->win_main_layout,
 489                                                                                 EVAS_CALLBACK_RESIZE,
 490                                                                                 setting_password_ug_cb_resize,
 491                                                                                 passwordUG);
 492                                 __setting_password_ug_key_grab(passwordUG);
 493
 494                                 return passwordUG->ly_main;
 495                         }
 496                         else
 497                         {
 498                                 /* unexpected case */
 499                                 SETTING_TRACE_DEBUG("[ERROR] no policy");
 500                                 if (SETTING_PW_TYPE_MDM_NEW_POLICY == passwordUG->view_type)
 501                                         passwordUG->view_type = SETTING_PW_TYPE_SET_PASSWORD;
 502                                 else if (SETTING_PW_TYPE_MDM_CHANGE_PASSWORD == passwordUG->view_type)
 503                                         passwordUG->view_type = SETTING_PW_TYPE_CHANGE_PASSWORD;
 504                         }
 505                 }
 506                 else
 507                 {
 508                         SETTING_TRACE_DEBUG("[ERROR] failed to connect mdm server");
 509                 }
 510         }
 511 #endif
 512 #ifdef SUPPORT_MDM
 513         if (SETTING_PW_TYPE_CHANGE_PASSWORD == passwordUG->view_type)
 514         {
 515                 // to do : if policy exist and quality is not unspecified,
 516                 //                      change view type to SETTING_PW_TYPE_MDM_CHANGE_PASSWORD
 517                 if((passwordUG->mdm_policy) && (passwordUG->mdm_policy->quality != MDM_PASSWORD_QUALITY_UNSPECIFIED))
 518                 {
 519                         passwordUG->view_type = SETTING_PW_TYPE_MDM_CHANGE_PASSWORD;
 520                         SETTING_TRACE_DEBUG("change view type to SETTING_PW_TYPE_MDM_CHANGE_PASSWORD");
 521                 }
 522                 // end
 523         }
 524 #endif
 525         /*  creating a view. */
 526         setting_view_create(&setting_view_password_main,(void *)passwordUG);
 527         evas_object_event_callback_add(passwordUG->win_main_layout,
 528                                                EVAS_CALLBACK_RESIZE,
 529                                                setting_password_ug_cb_resize,
 530                                                passwordUG);
 531         return passwordUG->ly_main;
 532 }
 533
 534 static void setting_password_ug_on_start(ui_gadget_h ug, service_h service, void *priv)
 535 {
 536 }
 537
 538 static void setting_password_ug_on_pause(ui_gadget_h ug, service_h service, void *priv)
 539 {
 540 }
 541
 542 static void setting_password_ug_on_resume(ui_gadget_h ug, service_h service, void *priv)
 543 {
 544 }
 545
 546 static void setting_password_ug_on_destroy(ui_gadget_h ug, service_h service, void *priv)
 547 {
 548         SettingPasswordUG *passwordUG = (SettingPasswordUG *)priv;
 549
 550         evas_object_event_callback_del(passwordUG->win_main_layout, EVAS_CALLBACK_RESIZE, setting_password_ug_cb_resize);       /* fix flash issue for gallery */
 551         passwordUG->ug = ug;
 552         setting_tapi_finize(passwordUG);
 553
 554         if (passwordUG->t_info) {
 555                 FREE(passwordUG->t_info);
 556         }
 557         if(passwordUG->remove_timer)
 558         {
 559                 ecore_timer_del(passwordUG->remove_timer);
 560                 passwordUG->remove_timer = NULL;
 561         }
 562 #ifdef SUPPORT_MDM
 563         if(passwordUG->event_handler)
 564         {
 565                 __setting_password_ug_key_ungrab(passwordUG);
 566         }
 567         if(passwordUG->mdm_status == MDM_RESULT_SUCCESS)
 568         {
 569                 mdm_release_service();
 570         }
 571 #endif
 572
 573         /*  delete the allocated objects. */
 574         setting_view_destroy(&setting_view_password_main, passwordUG);
 575         if (NULL != ug_get_layout(passwordUG->ug)) {
 576                 evas_object_hide((Evas_Object *) ug_get_layout(passwordUG->ug));
 577                 evas_object_del((Evas_Object *) ug_get_layout(passwordUG->ug));
 578         }
 579 }
 580
 581 static void setting_password_ug_on_message(ui_gadget_h ug, service_h msg,
 582                                            service_h service, void *priv)
 583 {
 584
 585 }
 586
 587 static void setting_password_ug_on_event(ui_gadget_h ug,
 588                                          enum ug_event event, service_h service,
 589                                          void *priv)
 590 {
 591         switch (event) {
 592         case UG_EVENT_LOW_MEMORY:
 593                 break;
 594         case UG_EVENT_LOW_BATTERY:
 595                 break;
 596         case UG_EVENT_LANG_CHANGE:
 597                 break;
 598         case UG_EVENT_ROTATE_PORTRAIT:
 599                 break;
 600         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 601                 break;
 602         case UG_EVENT_ROTATE_LANDSCAPE:
 603                 break;
 604         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 605                 break;
 606         case UG_EVENT_REGION_CHANGE:
 607                 break;
 608         default:
 609                 break;
 610         }
 611 }
 612
 613 static void setting_password_ug_on_key_event(ui_gadget_h ug,
 614                                              enum ug_key_event event,
 615                                              service_h service, void *priv)
 616 {
 617         if (!priv)
 618                 return;
 619
 620         SettingPasswordUG *ad = (SettingPasswordUG*)priv;
 621
 622         switch (event) {
 623         case UG_KEY_EVENT_END:
 624                 if(ad->remove_timer)
 625                 {
 626                         ecore_timer_del(ad->remove_timer);
 627                         ad->remove_timer = NULL;
 628                 }
 629                 ug_destroy_me(ug);
 630                 break;
 631         default:
 632                 break;
 633         }
 634 }
 635
 636 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 637 {
 638         SettingPasswordUG *passwordUG = calloc(1, sizeof(SettingPasswordUG));
 639         setting_retvm_if(!passwordUG, -1, "Create SettingPasswordUG obj failed");
 640
 641         ops->create = setting_password_ug_on_create;
 642         ops->start = setting_password_ug_on_start;
 643         ops->pause = setting_password_ug_on_pause;
 644         ops->resume = setting_password_ug_on_resume;
 645         ops->destroy = setting_password_ug_on_destroy;
 646         ops->message = setting_password_ug_on_message;
 647         ops->event = setting_password_ug_on_event;
 648         ops->key_event = setting_password_ug_on_key_event;
 649         ops->priv = passwordUG;
 650         ops->opt = UG_OPT_INDICATOR_ENABLE;
 651
 652         return 0;
 653 }
 654
 655 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 656 {
 657         struct SettingPasswordUG *passwordUG;
 658         setting_retm_if(!ops, "ops == NULL");
 659
 660         passwordUG = ops->priv;
 661         if (passwordUG)
 662                 FREE(passwordUG);
 663 }
 664
 665 void setting_sim_change_pins_cb(TapiHandle *handle, int result, void *data, void *user_data)
 666 {
 667         SETTING_TRACE_BEGIN;
 668         ret_if(!user_data || !data);
 669         TelSimPinOperationResult_t sec_rt = result;
 670         tapi_receive_info result_info = { 0, };
 671         TelSimSecResult_t *sim_event_data = (TelSimSecResult_t *) data;
 672         SETTING_TRACE("sec_rt[%d]", sec_rt);
 673         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 674         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 675
 676         if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt) {
 677                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
 678                         result_info.stat = SIM_PIN1_CHANGE_SUCCESS;
 679                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
 680                         result_info.stat = SIM_PIN2_CHANGE_SUCCESS;
 681         } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 682                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type) {
 683                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 684                         result_info.retry_cnt = sim_event_data->retry_count;
 685                 } else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type) {
 686                         result_info.stat = SIM_INCORRECT_PIN2_CODE;
 687                         result_info.retry_cnt = sim_event_data->retry_count;
 688                 }
 689         } else if (TAPI_SIM_PUK_REQUIRED == sec_rt) {
 690                 if (TAPI_SIM_PTYPE_PIN1 == sim_event_data->type)
 691                         result_info.stat = SIM_PIN1_BLOCKED;
 692                 else if (TAPI_SIM_PTYPE_PIN2 == sim_event_data->type)
 693                         result_info.stat = SIM_PIN2_BLOCKED;
 694         } else {
 695                 SETTING_TRACE_DEBUG
 696                     ("%s*** [ERR] INCORRECTED ***%s",
 697                      SETTING_FONT_RED, SETTING_FONT_BLACK);
 698                 return;
 699         }
 700         setting_password_ug_display_result_popup(&result_info, user_data);
 701 }
 702
 703 void setting_sim_verify_puks_cb(TapiHandle *handle, int result, void *data, void *user_data)
 704 {
 705         SETTING_TRACE_BEGIN;
 706
 707         ret_if(!user_data || !data);
 708         SettingPasswordUG *ad = user_data;
 709         TelSimPinOperationResult_t sec_rt = result;
 710         tapi_receive_info result_info = { 0, };
 711         TelSimSecResult_t *sim_event_data = (TelSimSecResult_t *) data;
 712         ad->verify_puks_result = sim_event_data;
 713         SETTING_TRACE("sec_rt[%d]", sec_rt);
 714         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 715         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 716
 717         if (TAPI_SIM_PTYPE_PUK1 == sim_event_data->type)
 718         {
 719                 //if (TAPI_SIM_PIN_REQUIRED == sec_rt){
 720                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt){
 721                         setting_password_ug_create_popup_notitle_nobtn(ad, _("Verfy PUK1 Sucessfully"), TRUE);
 722                         return;
 723                 } else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 724                         result_info.stat = SIM_INCORRECT_PUK1_CODE;
 725                         result_info.retry_cnt = sim_event_data->retry_count;
 726                 } else {
 727                         result_info.stat = SIM_UNKNOWN_ERROR;
 728                 }
 729         }
 730
 731         else if (TAPI_SIM_PTYPE_PUK2 == sim_event_data->type)
 732         {
 733                 //if (TAPI_SIM_PUK_REQUIRED == sec_rt)
 734                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt){
 735                         setting_password_ug_create_popup_notitle_nobtn(ad, _("Verfy PUK2 Sucessfully"), TRUE);
 736                         return;
 737                 } else if (TAPI_SIM_PUK_INCORRECT_PASSWORD == sec_rt) {
 738                         result_info.stat = SIM_INCORRECT_PUK2_CODE;
 739                         result_info.retry_cnt = sim_event_data->retry_count;
 740                 } else {
 741                         result_info.stat = SIM_UNKNOWN_ERROR;
 742                 }
 743         }
 744         else
 745         {
 746                 result_info.stat = SIM_UNKNOWN_ERROR;
 747         }
 748         setting_password_ug_display_result_popup(&result_info, user_data);
 749 }
 750
 751 void setting_sim_facility_enable_cb(TapiHandle *handle, int result, void *data, void *user_data)
 752 {
 753         SETTING_TRACE_BEGIN;
 754         ret_if(!user_data || !data);
 755         TelSimPinOperationResult_t sec_rt = result;
 756         tapi_receive_info result_info = { 0, };
 757         TelSimFacilityResult_t *sim_event_data = (TelSimFacilityResult_t *) data;
 758
 759         SETTING_TRACE("sec_rt[%d]", sec_rt);
 760         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 761         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 762
 763         /*  Sim Lock  */
 764         if (TAPI_SIM_LOCK_PS == sim_event_data->type) {
 765                 SETTING_TRACE("CASE TAPI_SIM_PTYPE_SIM == sim_event_data->type");
 766                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 767                         result_info.stat = SIM_LOCK_ON_SUCCESS;
 768                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt)
 769                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
 770                 else {
 771                         SETTING_TRACE_DEBUG("%s*** [ERR] INCORRECTED ***%s",
 772                              SETTING_FONT_RED,
 773                              SETTING_FONT_BLACK);
 774                         return;
 775                 }
 776         }
 777         /*  Pin Lock */
 778         else if (TAPI_SIM_LOCK_SC == sim_event_data->type) {
 779                 SETTING_TRACE("CASE TAPI_SIM_PTYPE_PIN1 == sim_event_data->type");
 780                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 781                         result_info.stat = SIM_PIN_LOCK_ON_SUCCESS;
 782                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 783                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 784                         result_info.retry_cnt = sim_event_data->retry_count;
 785                 } else if (TAPI_SIM_PUK_REQUIRED == sec_rt)
 786                         result_info.stat = SIM_PIN1_BLOCKED;
 787
 788                 /*  Pre CCF */
 789                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == sec_rt
 790                          || TAPI_SIM_CARD_ERROR == sec_rt) {
 791                         /*  popup */
 792                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
 793                 }
 794                 else {
 795                         SETTING_TRACE_DEBUG
 796                             ("%s*** [ERR] INCORRECTED ***%s",
 797                              SETTING_FONT_RED,
 798                              SETTING_FONT_BLACK);
 799                         return;
 800                 }
 801         }
 802         setting_password_ug_display_result_popup(&result_info, user_data);
 803 }
 804 void setting_sim_facility_disable_cb(TapiHandle *handle, int result, void *data, void *user_data)
 805 {
 806         SETTING_TRACE_BEGIN;
 807         ret_if(!user_data || !data);
 808         TelSimPinOperationResult_t sec_rt = result;
 809         tapi_receive_info result_info = { 0, };
 810         TelSimFacilityResult_t *sim_event_data = (TelSimFacilityResult_t *) data;
 811         SETTING_TRACE("sec_rt[%d]", sec_rt);
 812         SETTING_TRACE("sim_event_data->type:%d", sim_event_data->type);
 813         SETTING_TRACE("sim_event_data->retry_count[%d]", sim_event_data->retry_count);
 814
 815         /*  Sim Lock  */
 816         if (TAPI_SIM_LOCK_PS == sim_event_data->type) {
 817                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 818                         result_info.stat = SIM_LOCK_OFF_SUCCESS;
 819                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt)
 820                         result_info.stat = SIM_LOCK_INCORRECT_PASSWORD;
 821                 else {
 822                         SETTING_TRACE_DEBUG
 823                             ("%s*** [ERR] INCORRECTED ***%s",
 824                              SETTING_FONT_RED,
 825                              SETTING_FONT_BLACK);
 826                         return;
 827                 }
 828         }
 829         /*  Pin Lock */
 830         else if (TAPI_SIM_LOCK_SC == sim_event_data->type) {
 831                 if (TAPI_SIM_PIN_OPERATION_SUCCESS == sec_rt)
 832                         result_info.stat = SIM_PIN_LOCK_OFF_SUCCESS;
 833                 else if (TAPI_SIM_PIN_INCORRECT_PASSWORD == sec_rt) {
 834                         result_info.stat = SIM_INCORRECT_PIN1_CODE;
 835                         result_info.retry_cnt = sim_event_data->retry_count;
 836                 } else if (TAPI_SIM_PUK_REQUIRED == sec_rt)
 837                         result_info.stat = SIM_PIN1_BLOCKED;
 838
 839                 /*  Pre CCF */
 840                 else if (TAPI_SIM_INCOMPATIBLE_PIN_OPERATION == sec_rt
 841                          || TAPI_SIM_CARD_ERROR == sec_rt) {
 842                         /*  popup */
 843                         result_info.stat = SIM_OPERATION_UNAVAILABLE;
 844                 }
 845                 else {
 846                         SETTING_TRACE_DEBUG
 847                             ("%s*** [ERR] INCORRECTED ***%s",
 848                              SETTING_FONT_RED,
 849                              SETTING_FONT_BLACK);
 850                         return;
 851                 }
 852         }
 853         setting_password_ug_display_result_popup(&result_info, user_data);
 854 }
 855
 856 static void setting_password_ug_display_result_popup(tapi_receive_info *result,
 857                                                      SettingPasswordUG *ad)
 858 {
 859         switch (result->stat) {
 860         case SIM_OPERATION_OK:
 861         case SIM_LOCK_ON_SUCCESS:
 862         case SIM_LOCK_OFF_SUCCESS:
 863         case SIM_PIN_LOCK_ON_SUCCESS:
 864         case SIM_PIN_LOCK_OFF_SUCCESS:
 865                 {
 866                         if (ad->view_type ==
 867                             SETTING_PW_TYPE_SIM_LOCK_OFF) {
 868                                 int err = SETTING_RETURN_SUCCESS;
 869                                 /*  reset VCONF */
 870                                 setting_set_int_slp_key
 871                                     (INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT,
 872                                      SIM_LOCK_ATTEMPS_MAX, &err);
 873                                 setting_retm_if(err == SETTING_RETURN_FAIL,
 874                                                 "[Error] set value of vconf fail.");
 875                         }
 876                         /*  Success to Operate */
 877                         service_h svc;
 878                         if (service_create(&svc))
 879                                 return;
 880
 881                         service_add_extra_data(svc, "result", ad->view_type_string);
 882                         ug_send_result(ad->ug, svc);
 883                         SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
 884
 885                         service_destroy(svc);
 886                         /* Send destroy request */
 887                         ug_destroy_me(ad->ug);
 888                 }
 889                 break;
 890         case SIM_LOCK_INCORRECT_PASSWORD:
 891                 ad->focus_data = ad->ed_pw1;
 892                 setting_password_ug_check_attemps_left(ad);
 893                 break;
 894         case SIM_INCORRECT_PIN1_CODE:
 895                 {
 896                         const char *ret_str = NULL;
 897                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 898
 899                         if (result->retry_cnt > 1) {
 900                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
 901                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 902                                 setting_retm_if(ret < 0, "snprintf fail");
 903                                 ret_str = tmp_str;
 904                         } else {
 905                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN1");
 906                         }
 907                         ad->focus_data = ad->ed_pw1;
 908 #ifdef SUPPORT_POPUP
 909                         setting_password_ug_create_popup_notitle_nobtn(ad, (char *)ret_str, FALSE);
 910 #else
 911                         setting_password_ug_display_desc(ad, (char *)ret_str, FALSE);
 912 #endif
 913                 }
 914                 break;
 915         case SIM_INCORRECT_PIN2_CODE:
 916                 {
 917                         char *ret_str = NULL;
 918                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 919
 920                         if (result->retry_cnt > 1) {
 921                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PIN_PD_ATTEMPTS_LEFT', must transform */
 922                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PIN_ERR_DESC, result->retry_cnt);
 923                                 setting_retm_if(ret < 0, "snprintf fail");
 924                                 ret_str = tmp_str;
 925                         } else {
 926                                 ret_str = _("IDS_ST_POP_INCORRECT_PIN2");
 927                         }
 928                         ad->focus_data = ad->ed_pw1;
 929 #ifdef SUPPORT_POPUP
 930                         setting_password_ug_create_popup_notitle_nobtn(ad, ret_str, FALSE);
 931 #else
 932                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 933 #endif
 934                 }
 935                 break;
 936         case SIM_INCORRECT_PUK1_CODE:
 937                 {
 938                         char *ret_str = NULL;
 939                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 940
 941                         if (result->retry_cnt > 1) {
 942                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK1_PD_ATTEMPTS_LEFT', must transform */
 943                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK1_ERR_DESC, result->retry_cnt);
 944                                 setting_retm_if(ret < 0, "snprintf fail");
 945                                 ret_str = tmp_str;
 946                         } else {
 947                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK1_CODE");
 948                         }
 949                         ad->focus_data = ad->ed_pw1;
 950 #ifdef SUPPORT_POPUP
 951                         setting_password_ug_create_popup_notitle_nobtn(ad, ret_str, FALSE);
 952 #else
 953                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 954 #endif
 955                 }
 956                 break;
 957         case SIM_INCORRECT_PUK2_CODE:
 958                 {
 959                         char *ret_str = NULL;
 960                         char tmp_str[SETTING_STR_SLP_LEN] = {0,};
 961                         if (result->retry_cnt > 1) {
 962                                 /* there has '%d' in 'IDS_ST_POP_INCORRECT_PUK2_PD_ATTEMPTS_LEFT', must transform*/
 963                                 int ret = snprintf(tmp_str, SETTING_STR_SLP_LEN, PUK2_ERR_DESC, result->retry_cnt);
 964                                 setting_retm_if(ret < 0, "snprintf fail");
 965                                 ret_str = tmp_str;
 966                         } else {
 967                                 ret_str = _("IDS_ST_POP_INCORRECT_PUK2");
 968                         }
 969                         ad->focus_data = ad->ed_pw1;
 970 #ifdef SUPPORT_POPUP
 971                         setting_password_ug_create_popup_notitle_nobtn(ad, ret_str, FALSE);
 972 #else
 973                         setting_password_ug_display_desc(ad, ret_str, FALSE);
 974 #endif
 975                 }
 976                 break;
 977         case SIM_PIN1_CHANGE_SUCCESS:
 978                 setting_password_ug_create_popup_notitle_nobtn(ad,
 979                                                                _("IDS_ST_POP_PIN1_CHANGED"), TRUE);
 980                 break;
 981         case SIM_PIN2_CHANGE_SUCCESS:
 982                 setting_password_ug_create_popup_notitle_nobtn(ad,
 983                                                                _("IDS_ST_POP_PIN2_CHANGED"), TRUE);
 984                 break;
 985         case SIM_PIN1_BLOCKED:
 986                 setting_password_ug_create_popup_notitle_nobtn(ad,
 987                                                                _("IDS_ST_POP_PIN1_BLOCKED"), TRUE);
 988                 break;
 989         case SIM_PIN2_BLOCKED:
 990                 setting_password_ug_create_popup_notitle_nobtn(ad,
 991                                                                _("IDS_ST_POP_PIN2_BLOCKED"), TRUE);
 992                 break;
 993         case SIM_PIN1_UNBLOCKED:
 994                 setting_password_ug_create_popup_notitle_nobtn(ad,
 995                                                                _("IDS_ST_POP_PIN_UNBLOCKED"), TRUE);
 996                 break;
 997         case SIM_PIN2_UNBLOCKED:
 998                 setting_password_ug_create_popup_notitle_nobtn(ad,
 999                                                                _("IDS_ST_POP_PIN2_UNBLOCKED"), TRUE);
1000                 break;
1001         case SIM_PUK1_BLOCKED:
1002                 setting_password_ug_create_popup_notitle_nobtn(ad,
1003                                        _("IDS_ST_BODY_PUK1_BLOCKED"), TRUE);
1004                 /*  Call Permernent UG */
1005                 break;
1006         case SIM_PUK2_BLOCKED:
1007                 setting_password_ug_create_popup_notitle_nobtn(ad,
1008                                        _("IDS_ST_BODY_PUK2_BLOCKED"), TRUE);
1009                 /*  Call Permernent UG */
1010                 break;
1011         case SIM_REQUIRED_PUK_CODE:
1012                 break;
1013         case SIM_OPERATION_UNAVAILABLE:
1014                 setting_password_ug_create_popup_notitle_nobtn(ad,
1015                                        _("IDS_ST_HEADER_UNAVAILABLE"), TRUE);
1016                 break;
1017         case SIM_UNKNOWN_ERROR:
1018                 setting_password_ug_create_popup_notitle_nobtn(ad,
1019                                        _("IDS_ST_POP_UNKNOWN_OPERATION"), FALSE);
1020                 break;
1021         case SIM_ERROR:
1022         case SIM_REQ_PIN:
1023         case SIM_OPERATION_OFF:
1024         case SIM_LOCK_ON_FAIL:
1025         case SIM_PIN1_CHANGE_FAIL:
1026         case SIM_PIN2_CHANGE_FAIL:
1027                 break;
1028         default:
1029                 break;
1030         }
1031
1032         SETTING_TRACE_END;
1033 }
1034
1035 void setting_password_ug_popup_resp_cb(void *data, Evas_Object *obj,
1036                                        void *event_info)
1037 {
1038         retm_if(data == NULL, "Data parameter is NULL");
1039
1040         service_h svc;
1041         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1042         if (ad->destroy) {
1043                 /*  Success to Operate */
1044
1045                 if (service_create(&svc))
1046                         return;
1047
1048                 service_add_extra_data(svc, "result", ad->view_type_string);
1049                 ug_send_result(ad->ug, svc);
1050                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
1051
1052                 service_destroy(svc);
1053                 /* Send destroy request */
1054                 ug_destroy_me(ad->ug);
1055         } else {
1056                 char *diable_view_type = NULL;
1057                 //if (ad->disable_item_type == SETTING_PW_TYPE_PASSWORD) {
1058                 //      diable_view_type = "SETTING_PW_TYPE_PHONE_LOCK_DISABLE";
1059                 //} else
1060                 if (ad->disable_item_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
1061                         diable_view_type = "SETTING_PW_TYPE_SIM_LOCK_DISABLE";
1062                 }
1063
1064                 if (diable_view_type) {
1065                         /*  Success to Operate */
1066
1067                         if (service_create(&svc))
1068                                 return;
1069
1070                         service_add_extra_data(svc, "result", diable_view_type);
1071                         ug_send_result(ad->ug, svc);
1072
1073                         service_destroy(svc);
1074                         /* Send destroy request */
1075                         ug_destroy_me(ad->ug);
1076                 }
1077                 if (ad->focus_data) {
1078                         ad->focus_data->isFocusFlag = TRUE;
1079                         elm_object_item_data_set(ad->focus_data->item, ad->focus_data);
1080                         elm_genlist_item_update(ad->focus_data->item);
1081                 }
1082         }
1083 }
1084 static Eina_Bool __remove_desc(void *data)
1085 {
1086         SETTING_TRACE_BEGIN;
1087         retv_if(data == NULL, EINA_FALSE);
1088
1089         SettingPasswordUG *ad = (SettingPasswordUG *)data;
1090
1091         if(ad->err_desc)
1092         {
1093                 elm_object_item_del(ad->err_desc);
1094                 ad->err_desc = NULL;
1095         }
1096
1097         if(ad->remove_timer)
1098         {
1099                 ecore_timer_del(ad->remove_timer);
1100                 ad->remove_timer = NULL;
1101         }
1102
1103         if (ad->destroy) {
1104                 /*  Success to Operate */
1105
1106                 service_h svc;
1107                 if (service_create(&svc))
1108                         return EINA_FALSE;
1109
1110                 service_add_extra_data(svc, "result", ad->view_type_string);
1111                 ug_send_result(ad->ug, svc);
1112                 SETTING_TRACE("Send Result : %s\n", ad->view_type_string);
1113
1114                 service_destroy(svc);
1115                 /* Send destroy request */
1116                 ug_destroy_me(ad->ug);
1117         } else {
1118                 char *diable_view_type = NULL;
1119                 //if (ad->disable_item_type == SETTING_PW_TYPE_PASSWORD) {
1120                 //      diable_view_type = "SETTING_PW_TYPE_PHONE_LOCK_DISABLE";
1121                 //} else
1122                 if (ad->disable_item_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
1123                         diable_view_type = "SETTING_PW_TYPE_SIM_LOCK_DISABLE";
1124                 }
1125
1126                 if (diable_view_type) {
1127                         /*  Success to Operate */
1128
1129                         service_h svc;
1130                         if (service_create(&svc))
1131                                 return EINA_FALSE;
1132
1133                         service_add_extra_data(svc, "result", diable_view_type);
1134                         ug_send_result(ad->ug, svc);
1135
1136                         service_destroy(svc);
1137                         /* Send destroy request */
1138                         ug_destroy_me(ad->ug);
1139                 }
1140         }
1141         return ECORE_CALLBACK_CANCEL;
1142 }
1143
1144 void setting_password_ug_display_desc(void *data, char *desc, int destroy)
1145 {
1146         SETTING_TRACE_BEGIN;
1147         ret_if(data == NULL || desc == NULL);
1148
1149         SettingPasswordUG *ad = (SettingPasswordUG *)data;
1150
1151 #ifdef SUPPORT_MDM
1152         if(ad->view_type == SETTING_PW_TYPE_MDM_NEW_POLICY)
1153                 return;
1154 #endif
1155
1156         ad->destroy = destroy;
1157
1158         if(ad->scroller == NULL)
1159                 return;
1160
1161         if(ad->err_desc)
1162         {
1163                 elm_object_item_del(ad->err_desc);
1164                 ad->err_desc = NULL;
1165         }
1166
1167         ad->err_desc = elm_genlist_item_append(ad->scroller, &(ad->itc_err_desc), desc, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
1168         ad->remove_timer = ecore_timer_add(2.0, __remove_desc, ad);
1169
1170         /* if pw incorrect, show keyboard again. */
1171         if(ad->ed_pw1)
1172         {
1173                 SETTING_TRACE_DEBUG("FOCUS IN");
1174                 ad->ed_pw1->isFocusFlag = TRUE;
1175                 elm_object_focus_set(ad->ed_pw1->eo_check, EINA_TRUE);
1176         }
1177 }
1178
1179 void
1180 setting_password_ug_create_popup_notitle_nobtn(void *data, char *str,
1181                                                int destroy)
1182 {
1183         /* error check */
1184         retm_if(data == NULL, "Data parameter is NULL");
1185
1186         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1187
1188         ad->destroy = destroy;
1189         if(ad->notify)
1190         {
1191                 evas_object_del(ad->notify);
1192                 ad->notify = NULL;
1193         }
1194         ad->notify = setting_create_popup_without_btn(ad, ad->ly_main, NULL, str,
1195                                           setting_password_ug_popup_resp_cb,
1196                                           POPUP_INTERVAL, FALSE, FALSE);
1197 }
1198
1199 void setting_password_ug_check_attemps_left(void *data)
1200 {
1201         ret_if(!data);
1202         SettingPasswordUG *ad = (SettingPasswordUG *) data;
1203
1204         setting_int_slp_list item_attempts_left;
1205         setting_str_slp_list item_lock_timestamp;
1206         int attemps_left_max = 5;
1207
1208         if (ad->view_type == SETTING_PW_TYPE_PASSWORD) {
1209                 item_attempts_left = INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT;
1210                 item_lock_timestamp = STR_SLP_SETTING_PHONE_LOCK_TIMESTAMP;
1211                 attemps_left_max = PHONE_LOCK_ATTEMPS_MAX;
1212         } else if (ad->view_type == SETTING_PW_TYPE_SIM_LOCK_OFF) {
1213                 item_attempts_left = INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT;
1214                 item_lock_timestamp = STR_SLP_SETTING_SIM_LOCK_TIMESTAMP;
1215                 attemps_left_max = SIM_LOCK_ATTEMPS_MAX;
1216         } else {
1217                 return;
1218         }
1219
1220         int value = -1;
1221         int err = SETTING_RETURN_SUCCESS;
1222         setting_get_int_slp_key(item_attempts_left, &value, &err);
1223         setting_retm_if(err == SETTING_RETURN_FAIL,
1224                         "[Error] get value of vconf fail.");
1225
1226         value--;
1227
1228         if (value > 0 && value <= attemps_left_max) {
1229                 setting_set_int_slp_key(item_attempts_left, value, &err);
1230                 setting_retm_if(err == SETTING_RETURN_FAIL, "[Error] set value of vconf fail.");
1231                 char temp_str[MAX_SPECIALIZITION_LEN] = {0,};
1232                 char temp[MAX_SPECIALIZITION_LEN] ={0,};
1233
1234                 if(value > 1)
1235                         snprintf(temp, sizeof(temp), "%s. %s.", PW_ERR_DESC, ATTEMPTS_DESC);
1236                 else
1237                         snprintf(temp, sizeof(temp), "%s. %s.", PW_ERR_DESC, ATTEMPT_DESC);
1238
1239                 int ret = snprintf(temp_str, MAX_SPECIALIZITION_LEN, temp, value);
1240
1241                 ret_if(ret < 0);
1242
1243 #ifdef SUPPORT_POPUP
1244                 setting_password_ug_create_popup_notitle_nobtn(ad, temp_str, FALSE);
1245 #else
1246                 setting_password_ug_display_desc(ad, temp_str, FALSE);
1247 #endif
1248         } else if (value == 0) {
1249                 /*  store the lock timestamp */
1250                 time_t cur_time = time(NULL);
1251                 char cur_timestamp[LOCK_TIMESTAMP_LEN] = { 0, };
1252                 int ret = snprintf(cur_timestamp, sizeof(cur_timestamp), "%ld", cur_time);
1253                 ret_if(ret < 0);
1254
1255                 setting_set_string_slp_key(item_lock_timestamp, cur_timestamp, &err);
1256                 setting_retm_if(err == SETTING_RETURN_FAIL,
1257                                 "[Error] set value of vconf fail.");
1258
1259                 setting_set_int_slp_key(item_attempts_left, value, &err);
1260                 setting_retm_if(err == SETTING_RETURN_FAIL,
1261                                 "[Error] set value of vconf fail.");
1262
1263                 ad->disable_item_type = ad->view_type;
1264
1265                 char temp[MAX_SPECIALIZITION_LEN] = {0,};
1266                 snprintf(temp, sizeof(temp), PW_ERR_DELAY_DESC, PW_ERR_DELAY_TIME);
1267
1268                 setting_password_ug_create_popup_notitle_nobtn(ad, temp, FALSE);
1269         } else {
1270                 setting_password_ug_create_popup_notitle_nobtn(ad,
1271                                                                _("IDS_COM_POP_ERROR"), FALSE);
1272         }
1273
1274 }
1275
1276 int setting_password_is_password_empty()
1277 {
1278         SETTING_TRACE_BEGIN;
1279         int ret = 0;
1280         unsigned int attempt = 0;
1281         unsigned int max_attempt = 0;
1282         unsigned int expire_sec = 0;
1283
1284         ret = security_server_is_pwd_valid(&attempt, &max_attempt, &expire_sec);
1285         SETTING_TRACE_DEBUG("status of password : %d", ret);
1286
1287         if(ret == SECURITY_SERVER_API_ERROR_NO_PASSWORD)
1288                 return SETTING_RETURN_SUCCESS;
1289         else
1290                 return SETTING_RETURN_FAIL;
1291 }
1292 int setting_password_check_password(const char *challenge, unsigned int *remain_attempt, unsigned int *valid_sec)
1293 {
1294         SETTING_TRACE_BEGIN;
1295         retv_if(challenge == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1296
1297         int inner_ret = 0;
1298         int ret = 0;
1299         unsigned int current_attempt = 0;
1300         unsigned int max_attempt = 0;
1301         unsigned int valid_secs = 0;
1302
1303         inner_ret = security_server_chk_pwd(challenge, &current_attempt, &max_attempt, &valid_secs);
1304
1305         SETTING_TRACE_DEBUG("chk password : %d", inner_ret);
1306         SETTING_TRACE_DEBUG("current_attempt : %d, max_attempt : %d, valid_secs : %d secs", current_attempt, max_attempt, valid_secs);
1307
1308         if(inner_ret == SECURITY_SERVER_API_SUCCESS)
1309         {
1310                 ret = SETTING_RETURN_SUCCESS;
1311         }
1312         else
1313         {
1314                 if(remain_attempt != NULL)
1315                 {
1316                         if(max_attempt > 0)
1317                                 *remain_attempt = max_attempt - current_attempt;
1318         else
1319                                 *remain_attempt = ATTEMPT_INFINITE;     // infinite
1320                         ret = SETTING_RETURN_FAIL;
1321                 }
1322         }
1323
1324         if(valid_sec != NULL)
1325                 *valid_sec = valid_secs;
1326
1327         return ret;
1328 }
1329 #ifdef SUPPORT_MDM
1330 static Eina_Bool __set_history_cb(void *data)
1331 {
1332         SETTING_TRACE_BEGIN;
1333         retv_if(data == NULL, EINA_FALSE);
1334
1335         SettingPasswordUG *ad = (SettingPasswordUG *)data;
1336
1337         if(ad->mdm_policy)
1338                 security_server_set_pwd_history(ad->mdm_policy->history_cnt);
1339
1340         return EINA_FALSE;
1341 }
1342 #endif
1343
1344 int setting_password_set_password(const char *cur_pwd, const char *new_pwd, void *data)
1345 {
1346         SETTING_TRACE_BEGIN;
1347         retv_if(new_pwd == NULL || data == NULL, SETTING_GENERAL_ERR_NULL_DATA_PARAMETER);
1348
1349         SettingPasswordUG *ad = (SettingPasswordUG*)data;
1350         int ret = 0;
1351
1352 #ifdef SUPPORT_MDM
1353         if((ad->view_type == SETTING_PW_TYPE_MDM_NEW_POLICY)
1354                 || (ad->view_type == SETTING_PW_TYPE_MDM_TO_SIMPLE))
1355         {
1356                 if(cur_pwd)
1357                 {
1358                         SETTING_TRACE_DEBUG("cur_pwd : %s, new_pwd : %s", cur_pwd, new_pwd);
1359                         ret = security_server_set_pwd(cur_pwd, new_pwd, ad->mdm_policy->max_num_wipe, ad->mdm_policy->expire);
1360
1361                         if(ret == SECURITY_SERVER_API_ERROR_PASSWORD_REUSED)
1362                         {
1363                                 SETTING_TRACE_DEBUG("[ERROR - security_server_set_pwd()] password reused");
1364                         }
1365                         else
1366                         {
1367                                 SETTING_TRACE_DEBUG("[security_server_set_pwd()] returns %d", ret);
1368                         }
1369                 }
1370                 else
1371                 {
1372                         SETTING_TRACE_DEBUG("new_pwd : %s", new_pwd);
1373                         ret = mdm_reset_password((char*)new_pwd);
1374                         SETTING_TRACE_DEBUG("[mdm_reset_password()] returns %d", ret);
1375                 }
1376
1377                 if((ret == MDM_RESULT_SUCCESS) || (ret == SECURITY_SERVER_API_SUCCESS))
1378                 {
1379                         ad->set_history_timer = ecore_timer_add(1, (Ecore_Task_Cb)__set_history_cb, ad);
1380                         return SETTING_RETURN_SUCCESS;
1381                 }
1382                 else
1383                 {
1384                         return ret;
1385                 }
1386         }
1387         else
1388 #endif
1389         {
1390                 /* max attempt count will be handled in passwordug for a while. */
1391                 if(cur_pwd == NULL || ad->is_empty == TRUE)
1392                 {
1393                         ret = security_server_set_pwd(NULL, new_pwd, 0, PW_ERR_DELAY_TIME);
1394                         SETTING_TRACE_DEBUG("new_pwd : %s", new_pwd);
1395                 }
1396                 else
1397                 {
1398                         ret = security_server_set_pwd(cur_pwd, new_pwd, 0, PW_ERR_DELAY_TIME);
1399                         SETTING_TRACE_DEBUG("cur_pwd : %s, new_pwd : %s", cur_pwd, new_pwd);
1400                 }
1401                 SETTING_TRACE_DEBUG("set password : %d", ret);
1402
1403                 if(ret == SECURITY_SERVER_API_SUCCESS)
1404                         return SETTING_RETURN_SUCCESS;
1405                 else
1406                         return SETTING_RETURN_FAIL;
1407         }
1408 }