setting-common/src/setting-common-data-slp-setting.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-common-data-slp-setting.h>
  22 #include <Elementary.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <openssl/sha.h>
  26
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30
  31 #include <stdlib.h>
  32 #include <libxml/xmlmemory.h>
  33 #include <libxml/parser.h>
  34 #include <glib.h>
  35
  36 typedef enum
  37 {
  38         eBOOL,
  39         eINT,
  40         eSTRING,
  41 }vconftype;
  42
  43 typedef union {
  44         int i;
  45         bool b;
  46         char* c;
  47 } vconfval;
  48
  49
  50 typedef struct VconfNode VconfNode;
  51 struct VconfNode
  52 {
  53         int key;                                                                /** vconf id definded in Setting app */
  54         const char* vconf_key;                                  /** vconf string defined in libslp-setting */
  55         vconftype type;                                                 /** BOOL, INT, STRING */
  56         vconfval value;                                                 /** variable by union */
  57         void (*export)(VconfNode* pnode);               /** method for exporting current state */
  58 };
  59
  60
  61 // export function for each vconf key
  62 void export_default(VconfNode* node)
  63 {
  64         SETTING_TRACE("key : %s ",node->vconf_key);
  65 }
  66
  67
  68 /** bool vconf table */
  69 static VconfNode g_btable[] = {
  70
  71                 {BOOL_SLP_SETTING_POWER_ON_LOCK, VCONFKEY_SETAPPL_STATE_POWER_ON_LOCK_BOOL, eBOOL, {0}, export_default}, // node[0]
  72                 {BOOL_SLP_SETTING_SIMPLE_PASSWORD, VCONFKEY_SETAPPL_STATE_SIMPLE_PASSWORD_BOOL, eBOOL, {0}, export_default}, // node[0]
  73
  74                 {BOOL_SLP_SETTING_AUTOMATIC_TIME_UPDATE, VCONFKEY_SETAPPL_STATE_AUTOMATIC_TIME_UPDATE_BOOL, eBOOL,{0}, export_default},
  75
  76
  77                 {BOOL_SLP_SETTING_TRANSACTION_TRACKING, VCONFKEY_SETAPPL_STATE_TRANSACTION_TRACKING_BOOL, eBOOL,{0}, export_default},
  78
  79
  80                 {BOOL_SLP_SETTING_EXPIRY_REMINDER, VCONFKEY_SETAPPL_STATE_EXPIRY_REMINDER_BOOL, eBOOL,{0}, export_default},
  81
  82                 {BOOL_SLP_SETTING_FLIGHT_MODE, VCONFKEY_SETAPPL_FLIGHT_MODE_BOOL, eBOOL,{0}, export_default},
  83                 {BOOL_SLP_SETTING_DATA_ROAMING, VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL, eBOOL,{0}, export_default},
  84                 {BOOL_SLP_SETTING_NFC_STATUS,VCONFKEY_NFC_STATE, eBOOL, {0}, export_default},
  85
  86                 {BOOL_SLP_SETTING_USE_PACKET_DATA, VCONFKEY_3G_ENABLE, eBOOL,{0}, export_default},
  87                 {BOOL_SLP_SETTING_ACCESSIBILITY_ACCESSIBILITY, VCONFKEY_SETAPPL_ACCESSIBILITY_ACCESSIBILITY, eBOOL,{0}, export_default},
  88                 {BOOL_SLP_SETTING_ACCESSIBILITY_HIGH_CONTRAST, VCONFKEY_SETAPPL_ACCESSIBILITY_HIGH_CONTRAST, eBOOL,{0}, export_default},
  89                 {BOOL_SLP_SETTING_ACCESSIBILITY_SCREEN_ZOOM, VCONFKEY_SETAPPL_ACCESSIBILITY_SCREEN_ZOOM, eBOOL,{0}, export_default},
  90                 {BOOL_SLP_SETTING_ACCESSIBILITY_ASSISTIVE_LIGHT, VCONFKEY_SETAPPL_ACCESSIBILITY_TORCH_LIGHT, eBOOL,{0}, export_default},
  91                 {BOOL_SLP_SETTING_ACCESSIBILITY_MONO_AUDIO, VCONFKEY_SETAPPL_ACCESSIBILITY_MONO_AUDIO, eBOOL,{0}, export_default},
  92                 {BOOL_SLP_SETTING_ACCESSIBILITY_LED_NOTIFY, VCONFKEY_SETAPPL_ACCESSIBILITY_LED_NOTIFY, eBOOL,{0}, export_default},
  93                 {BOOL_SLP_SETTING_ACCESSIBILITY_ACCEPT_CALL, VCONFKEY_CISSAPPL_ANSWERING_KEY_BOOL, eBOOL,{0}, export_default},
  94                 {BOOL_SLP_SETTING_ACCESSIBILITY_POWERKEY_END_CALLS, VCONFKEY_CISSAPPL_POWER_KEY_ENDS_CALL_BOOL, eBOOL,{0}, export_default},
  95
  96                 //datausage
  97                 {BOOL_SLP_SETTING_DATAUSAGE_MOBILE_DATA_BOOL, VCONFKEY_SETAPPL_MOBILE_DATA_BOOL, eBOOL, {0}, export_default},
  98                 {BOOL_SLP_SETTING_DATAUSAGE_DISABLE_MOBILE_DATA_AT_LIMIT_BOOL, VCONFKEY_SETAPPL_DISABLE_MOBILE_DATA_AT_LIMIT_BOOL, eBOOL, {0}, export_default},
  99                 {BOOL_SLP_SETTING_DATAUSAGE_RESTRICT_BG_DATA_BOOL, VCONFKEY_SETAPPL_RESTRICT_BG_DATA_BOOL, eBOOL, {0}, export_default},
 100                 {BOOL_SLP_SETTING_DATAUSAGE_SHOW_WIFI_USAGE_BOOL, VCONFKEY_SETAPPL_SHOW_WIFI_USAGE_BOOL, eBOOL, {0}, export_default},
 101                 //------------------------------------------------------------------------------------------------
 102                 {SETTING_BOOL_SLP_LIST_MAX, NULL, eBOOL, {0}, export_default},
 103         };
 104
 105
 106 /** int vconf table */
 107 static VconfNode g_itable[] = {
 108                 {INT_SLP_SETTING_LCD_BRIGHTNESS, VCONFKEY_SETAPPL_LCD_BRIGHTNESS, eINT, {0}, export_default},
 109                 {INT_SLP_SETTING_LCD_TIMEOUT_NORMAL,VCONFKEY_SETAPPL_LCD_TIMEOUT_NORMAL, eINT, {0}, export_default},
 110                 {INT_SLP_SETTING_LCD_TIMEOUT_NORMAL_BACKUP,VCONFKEY_LCD_TIMEOUT_NORMAL_BACKUP, eINT, {0}, export_default},
 111
 112                 {INT_SLP_SETTING_AUTOMATIC_BRIGHTNESS, VCONFKEY_SETAPPL_BRIGHTNESS_AUTOMATIC_INT, eINT,{0}, export_default},
 113
 114                 {INT_SLP_SETTING_SELECT_NETWORK,VCONFKEY_SETAPPL_SELECT_NETWORK_INT, eINT, {0}, export_default},
 115                 {INT_SLP_SETTING_NETWORK_MODE,VCONFKEY_SETAPPL_NETWORK_MODE_INT, eINT, {0}, export_default},
 116                 {INT_SLP_SETTING_REGIONFORMAT_TIME1224,VCONFKEY_REGIONFORMAT_TIME1224, eINT, {0}, export_default},
 117                 {INT_SLP_SETTING_DATE_FORMAT,VCONFKEY_SETAPPL_DATE_FORMAT_INT, eINT, {0}, export_default},
 118                 {INT_SLP_SETTING_WEEK_FORMAT,VCONFKEY_SETAPPL_WEEKOFDAY_FORMAT_INT, eINT, {0}, export_default},
 119                 /* CALL_ALERT_TYPE */
 120                 {INT_SLP_SETTING_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default},
 121                 {INT_SLP_SETTING_NORMAL_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default},
 122                 {INT_SLP_SETTING_SILENT_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default},
 123                 {INT_SLP_SETTING_DRIVING_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default},
 124                 {INT_SLP_SETTING_MEETING_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default},
 125                 {INT_SLP_SETTING_OUTDOOR_CALL_ALERT_TYPE, NULL, eINT, {0}, export_default},
 126                 /* CALL_ALERT_VIB */
 127                 {INT_SLP_SETTING_CALL_ALERT_VIB, VCONFKEY_SETAPPL_CALL_VIBRATION_PATTERN_INT, eINT, {0}, export_default},
 128                 {INT_SLP_SETTING_NORMAL_CALL_ALERT_VIB, NULL, eINT, {0}, export_default},
 129                 {INT_SLP_SETTING_SILENT_CALL_ALERT_VIB, NULL, eINT, {0}, export_default},
 130                 {INT_SLP_SETTING_DRIVING_CALL_ALERT_VIB, NULL, eINT, {0}, export_default},
 131                 {INT_SLP_SETTING_MEETING_CALL_ALERT_VIB, NULL, eINT, {0}, export_default},
 132                 {INT_SLP_SETTING_OUTDOOR_CALL_ALERT_VIB, NULL, eINT, {0}, export_default},
 133
 134                 /*****/
 135                 {INT_SLP_SETTING_CALL_ALERT_VOLUME, NULL, eINT, {0}, export_default},
 136                 /* MSG_ALERT_TYPE */
 137                 {INT_SLP_SETTING_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default},
 138                 {INT_SLP_SETTING_NORMAL_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default},
 139                 {INT_SLP_SETTING_SILENT_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default},
 140                 {INT_SLP_SETTING_DRIVING_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default},
 141                 {INT_SLP_SETTING_MEETING_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default},
 142                 {INT_SLP_SETTING_OUTDOOR_MSG_ALERT_TYPE, NULL, eINT, {0}, export_default},
 143                 /* MSG_ALERT_VIB */
 144                 {INT_SLP_SETTING_MSG_ALERT_VIB, NULL, eINT, {0}, export_default},
 145                 {INT_SLP_SETTING_NORMAL_MSG_ALERT_VIB, NULL, eINT, {0}, export_default},
 146                 {INT_SLP_SETTING_SILENT_MSG_ALERT_VIB, NULL, eINT, {0}, export_default},
 147                 {INT_SLP_SETTING_DRIVING_MSG_ALERT_VIB, NULL, eINT, {0}, export_default},
 148                 {INT_SLP_SETTING_MEETING_MSG_ALERT_VIB, NULL, eINT, {0}, export_default},
 149                 {INT_SLP_SETTING_OUTDOOR_MSG_ALERT_VIB, NULL, eINT, {0}, export_default},
 150
 151                 /*****/
 152                 {INT_SLP_SETTING_MSG_ALERT_REPEAT,VCONFKEY_SETAPPL_NOTI_MSG_ALERT_REP_TYPE_INT, eINT, {0}, export_default},
 153                 {INT_SLP_SETTING_EMAIL_ALERT_REPEAT,VCONFKEY_SETAPPL_NOTI_EMAIL_ALERT_REP_TYPE_INT, eINT, {0}, export_default},
 154
 155                 /*****/
 156                 {INT_SLP_SETTING_MSG_ALERT_VOLUME, NULL, eINT, {0}, export_default},
 157                 {INT_SLP_SETTING_SYS_TOUCH_SOUND, NULL, eINT, {0}, export_default},
 158                 {INT_SLP_SETTING_SYS_TOUCH_SOUND_VOLUME, NULL, eINT, {0}, export_default},
 159                 {INT_SLP_SETTING_FONT_SIZE,VCONFKEY_SETAPPL_FONT_SIZE_INT, eINT, {0}, export_default},
 160                 {INT_SLP_SETTING_FONT_TYPE,VCONFKEY_SETAPPL_FONT_TYPE_INT, eINT, {0}, export_default},
 161                 {INT_SLP_SETTING_LANG,VCONFKEY_SETAPPL_LANG_INT, eINT, {0}, export_default},
 162                 {INT_SLP_SETTING_BT_STATUS,VCONFKEY_BT_STATUS, eINT, {0}, export_default},
 163                 {INT_SLP_SETTING_WIFI_STATUS,VCONFKEY_WIFI_STATE, eINT, {0}, export_default},
 164                 {INT_SLP_SETTING_ROAMING_NETWORK,VCONFKEY_SETAPPL_ROAMING_NETWORK_INT, eINT, {0}, export_default},
 165                 {INT_SLP_SETTING_USB_MODE,VCONFKEY_SETAPPL_USB_MODE_INT, eINT, {0}, export_default},
 166 #ifdef UNUSED_VCONFKEY
 167                 {INT_SLP_SETTING_TASKSWITCHER_VIEWTYPE,VCONFKEY_TASKSWITCHER_VIEWTYPE, eINT, {0}, export_default},
 168 #endif
 169                 /* memory */
 170                 {INT_SLP_SETTING_DEFAULT_MEM_WAP,VCONFKEY_SETAPPL_DEFAULT_MEM_WAP_INT, eINT, {0}, export_default},
 171                 {INT_SLP_SETTING_DEFAULT_MEM_BLUETOOTH,VCONFKEY_SETAPPL_DEFAULT_MEM_BLUETOOTH_INT, eINT, {0}, export_default},
 172                 {INT_SLP_SETTING_DEFAULT_MEM_CAMERA,VCONFKEY_SETAPPL_DEFAULT_MEM_CAMERA_INT, eINT, {0}, export_default},
 173                 {INT_SLP_SETTING_DEFAULT_MEM_VOICE_RECORDER,VCONFKEY_SETAPPL_DEFAULT_MEM_VOICE_RECORDER_INT, eINT, {0}, export_default},
 174                 {INT_SLP_SETTING_DEFAULT_MEM_FM_RADIO,VCONFKEY_SETAPPL_DEFAULT_MEM_FM_RADIO_INT, eINT, {0}, export_default},
 175                 {INT_SLP_SETTING_DEFAULT_MEM_ALL_SHARE,VCONFKEY_SETAPPL_DEFAULT_MEM_ALL_SHARE_INT, eINT, {0}, export_default},
 176                 {INT_SLP_SETTING_DEFAULT_MEM_ADOBE_AIR,VCONFKEY_SETAPPL_DEFAULT_MEM_ADOBE_AIR_INT, eINT, {0}, export_default},
 177                 {INT_SLP_SETTING_DEFAULT_MEM_DVB_H,VCONFKEY_SETAPPL_DEFAULT_MEM_DVB_H_INT, eINT, {0}, export_default},
 178
 179                 /* other module */
 180                 {INT_SLP_SETTING_SIM_SLOT,VCONFKEY_TELEPHONY_SIM_SLOT, eINT, {0}, export_default},
 181                 {INT_SLP_SETTING_PHONE_LOCK_ATTEMPTS_LEFT,VCONFKEY_SETAPPL_PHONE_LOCK_ATTEMPTS_LEFT_INT, eINT, {0}, export_default},
 182                 {INT_SLP_SETTING_SIM_LOCK_ATTEMPTS_LEFT,VCONFKEY_SETAPPL_SIM_LOCK_ATTEMPTS_LEFT_INT, eINT, {0}, export_default},
 183
 184                 // accessibility setting
 185                 {INT_SLP_SETTING_ACCESSIBILITY_ENABLE_AUTO_ANSWER, VCONFKEY_CISSAPPL_ANSWERING_MODE_INT, eINT,{0}, export_default},
 186                 {INT_SLP_SETTING_ACCESSIBILITY_FONT_SIZE, VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_SIZE, eINT, {0}, export_default},
 187 #if SUPPORT_FONT_STYLE
 188                 {INT_SLP_SETTING_ACCESSIBILITY_FONT_STYLE,VCONFKEY_SETAPPL_ACCESSIBILITY_FONT_STYLE, eINT, {0}, export_default},
 189 #endif
 190                 {INT_SLP_SETTING_ACCESSIBILITY_AUTO_ANSWER,     VCONFKEY_CISSAPPL_ANSWERING_MODE_TIME_INT, eINT, {0}, export_default},
 191                 {INT_SLP_SETTING_ACCESSIBILITY_POWER_KEY_HOLD, VCONFKEY_SETAPPL_ACCESSIBILITY_POWER_KEY_HOLD, eINT, {0}, export_default},
 192
 193                 //powersaving
 194                 {INT_SLP_SETTING_POWERSAVING_AT, VCONFKEY_SETAPPL_PWRSV_CUSTMODE_AT, eINT, {0}, export_default},
 195                 {INT_SLP_SETTING_POWERSAVING_SCREEN_TIMEOUT, VCONFKEY_SETAPPL_PWRSV_CUSTMODE_BLTIME, eINT, {0}, export_default},
 196                 {INT_SLP_SETTING_DEVOPTION_BGPROCESS, VCONFKEY_SETAPPL_DEVOPTION_BGPROCESS, eINT, {0}, export_default},
 197
 198                 {INT_SLP_SETTING_DATAUSAGE_DATA_EACH_MONTH_INT, VCONFKEY_SETAPPL_DATA_EACH_MONTH_INT, eINT, {0}, export_default},
 199                 {SETTING_INT_SLP_LIST_MAX, NULL, eINT, {0}, export_default},
 200 };
 201
 202
 203 /** string vconf table */
 204 static VconfNode g_stable[] = {
 205                     /* password code - special processing */
 206                 {       STR_SLP_LIST_PHONE_PASSWORD, NULL, eSTRING,{0}, export_default },
 207                 {       STR_SLP_SETTING_PHONE_LOCK_TIMESTAMP,VCONFKEY_SETAPPL_PHONE_LOCK_TIMESTAMP_STR, eSTRING,{0}, export_default },
 208                 {       STR_SLP_SETTING_SIM_LOCK_TIMESTAMP,VCONFKEY_SETAPPL_SIM_LOCK_TIMESTAMP_STR, eSTRING,{0}, export_default },
 209                 {       STR_SLP_SETTING_SELECT_NUM,VCONFKEY_SETAPPL_SELECTED_NUM, eSTRING,{0}, export_default },
 210                 {       STR_SLP_LIST_MAX, NULL, eSTRING, {0}, export_default},
 211 };
 212
 213 void setting_export()
 214 {
 215         int i = 0;
 216
 217         for (i=0;i<SETTING_BOOL_SLP_LIST_MAX;i++) {
 218                 SETTING_TRACE("exporting bool keys : %s ", g_btable[i].vconf_key );
 219                 // run export function --> store data into XML
 220                 g_btable[i].export(&g_btable[i]);
 221         }
 222
 223         for (i=0;i<SETTING_INT_SLP_LIST_MAX;i++) {
 224                 SETTING_TRACE("exporting int keys : %s ", g_itable[i].vconf_key );
 225                 // run export function --> store data into XML
 226                 g_itable[i].export(&g_itable[i]);
 227         }
 228
 229         for (i=0;i<STR_SLP_LIST_MAX;i++) {
 230                 SETTING_TRACE("exporting string keys : %s ", g_stable[i].vconf_key );
 231                 // run export function --> store data into XML
 232                 g_stable[i].export(&g_stable[i]);
 233         }
 234 }
 235
 236 int set_vconf(VconfNode node,VconfNode *result)
 237 {
 238         SETTING_TRACE_BEGIN;
 239         int ret = -1 ;
 240         //node.key
 241         //node.vconf_key
 242         *result = node;
 243         switch(node.type)
 244         {
 245         case eBOOL:
 246                 SETTING_TRACE("begin case eINT[%s=\"%d\"]", node.vconf_key, node.value.b);
 247                 ret = vconf_set_bool(node.vconf_key, node.value.b);
 248                 result->type = eBOOL;
 249                 result->value.b = node.value.b;
 250                 break;
 251         case eINT:
 252                 SETTING_TRACE("begin case eINT[%s=\"%d\"]", node.vconf_key, node.value.i);
 253                 ret = vconf_set_int(node.vconf_key, node.value.i);
 254                 result->type = eINT;
 255                 result->value.i = node.value.i;
 256                 break;
 257         case eSTRING:
 258                 if (node.key == STR_SLP_LIST_PHONE_PASSWORD) {
 259                         ret = setting_store_init_password(node.value.c);
 260                 } else {
 261                         SETTING_TRACE("begin case eINT[%s=\"%s\"]", node.vconf_key, node.value.c);
 262                         ret = vconf_set_str(node.vconf_key, node.value.c);
 263                 }
 264                 result->type = eSTRING;
 265                 result->value.c = node.value.c;
 266                 break;
 267         default:
 268                 SETTING_TRACE_ERROR(">>>>>>>>>> node.type is NOT DEFINED");
 269                 break;
 270         }
 271
 272         if (0 != ret)
 273         {
 274                 SETTING_TRACE_ERROR(">>>>>>>>>> Failed to set vconf");
 275         }
 276         //SETTING_TRACE("KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result->key, result->vconf_key, result->type, result->value.i);
 277         return ret;
 278 }
 279
 280
 281 int get_vconf(VconfNode node, VconfNode* result)
 282 {
 283         int ret = -1 ;
 284
 285         char md_result[SHA256_DIGEST_LENGTH];
 286         memset(md_result, 0x0, SHA256_DIGEST_LENGTH);
 287
 288
 289         *result = node;
 290
 291         switch(node.type)
 292         {
 293         case eBOOL:
 294                 ret = vconf_get_bool(node.vconf_key, (int *)(&(node.value.b)));
 295                 result->type = eBOOL;
 296                 result->value.b = node.value.b;
 297                 break;
 298         case eINT:
 299                 ret = vconf_get_int(node.vconf_key, &(node.value.i));
 300                 result->type = eINT;
 301                 result->value.i = node.value.i;
 302                 break;
 303         case eSTRING:
 304                 if (node.key == STR_SLP_LIST_PHONE_PASSWORD)
 305                 {
 306                         node.value.c = (char*)malloc(sizeof(char) * SHA256_DIGEST_LENGTH);
 307                         if (node.value.c) {
 308                                 memset(node.value.c, 0x0, SHA256_DIGEST_LENGTH);
 309                         } else {
 310                                 SETTING_TRACE_ERROR(" malloc filed : eSTRING, node.value.c ");
 311                                 ret = SETTING_RETURN_FAIL;
 312                                 goto endtag;
 313                         }
 314
 315                         if (setting_read_password(md_result) == 0) {
 316                                 memcpy(node.value.c, md_result, SHA256_DIGEST_LENGTH); /*  un-safe */
 317
 318                                 result->type = eSTRING;
 319                                 result->value.c = node.value.c;
 320                                 ret = SETTING_RETURN_SUCCESS;
 321                         } else {
 322                                 /*do nothing */
 323                                 ret = SETTING_RETURN_FAIL;
 324                                 goto endtag;
 325                         }
 326                 } else {
 327                         node.value.c = vconf_get_str(node.vconf_key);
 328                         SETTING_TRACE("string type ---> %s ", node.value.c);
 329                         result->type = eSTRING;
 330                         result->value.c = node.value.c;
 331                         ret = SETTING_RETURN_SUCCESS;
 332                 }
 333                 break;
 334         default:
 335                 SETTING_TRACE_ERROR(">>>>>>>>>>>>>>>>>>>>>>> get vconf ERROR : %s ", node.vconf_key );
 336         }
 337 endtag:
 338         return ret;
 339 }
 340
 341 int setting_set_bool_slp_key(setting_bool_slp_list key, int value, int *err)
 342 {
 343         SETTING_TRACE_BEGIN;
 344         int ret = SETTING_RETURN_FAIL;
 345
 346         /* error check */
 347         if (key < 0 || key >= SETTING_BOOL_SLP_LIST_MAX) {
 348                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 349                 return ret;
 350         }
 351
 352         VconfNode result;
 353         g_btable[key].value.b = value;
 354         ret = set_vconf(g_btable[key],&result);
 355
 356         SETTING_TRACE("setting_set_bool ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.b);
 357         SETTING_TRACE_END;
 358         return ret;
 359 }
 360
 361 int setting_get_bool_slp_key(setting_bool_slp_list key, int *value, int *err)
 362 {
 363         SETTING_TRACE_BEGIN;
 364         int ret = SETTING_RETURN_FAIL;
 365
 366         /* error check */
 367         if (key < 0 || key >= SETTING_BOOL_SLP_LIST_MAX) {
 368                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 369                 SETTING_TRACE_ERROR(" <<<<<<<< key is invalid >>>>>>>>>>>>> ");
 370                 return ret;
 371         }
 372         VconfNode result;
 373         ret = get_vconf(g_btable[key], &result);
 374         //*value = g_btable[key].value.b;
 375         *value = result.value.b;
 376         SETTING_TRACE_END;
 377         return ret;
 378 }
 379
 380 int setting_set_int_slp_key(setting_int_slp_list key, int value, int *err)
 381 {
 382         SETTING_TRACE_BEGIN;
 383         int ret = SETTING_RETURN_FAIL;
 384
 385         /* error check */
 386         if (key < 0 || key >= SETTING_INT_SLP_LIST_MAX) {
 387                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 388                 SETTING_TRACE(">>> key is invalid ");
 389                 return ret;
 390         }
 391
 392         VconfNode result;
 393         g_itable[key].value.i = value;
 394         ret = set_vconf(g_itable[key],&result);
 395         *err = ret;
 396         SETTING_TRACE("setting_set_int ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.i);
 397         SETTING_TRACE_END;
 398         return ret;
 399 }
 400
 401 /* return -1: fail  cannot use err to check the result, return value instead*/
 402 int setting_get_int_slp_key(setting_int_slp_list key, int *value, int *err)
 403 {
 404         SETTING_TRACE_BEGIN;
 405         int ret = SETTING_RETURN_FAIL;
 406
 407         /* error check */
 408         if (key < 0 || key >= SETTING_INT_SLP_LIST_MAX) {
 409                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 410                 return ret;
 411         }
 412
 413         VconfNode result;
 414         ret = get_vconf(g_itable[key], &result);
 415         //*value = g_itable[key].value.i;
 416         *value = result.value.i;
 417
 418         *err = ret;
 419         SETTING_TRACE_END;
 420         return ret;
 421 }
 422
 423 int setting_get_string_slp_key(setting_str_slp_list key, char *value, int *err)
 424 {
 425         SETTING_TRACE_BEGIN;
 426         int ret = SETTING_RETURN_FAIL;
 427
 428         /* error check */
 429         if (key < 0 || key >= STR_SLP_LIST_MAX || NULL == value) {
 430                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 431                 return ret;
 432         }
 433
 434         /** @todo check memory leack when passwork checking */
 435         VconfNode result;
 436         ret = get_vconf(g_stable[key], &result);
 437
 438         if (ret >= 0)
 439         {
 440                 safeCopyStr(value, result.value.c, strlen(result.value.c));
 441                 SETTING_TRACE(">>>>>>>> %s <<<<<<<<", value);
 442                 FREE(result.value.c);
 443         } else {
 444                 SETTING_TRACE("get_vconf is failed");
 445         }
 446         *err = ret;
 447         SETTING_TRACE_END;
 448         return ret;
 449 }
 450
 451 int setting_set_string_slp_key(setting_str_slp_list key, char *value, int *err)
 452 {
 453         int ret = SETTING_RETURN_FAIL;
 454
 455         /* error check */
 456         if (key < 0 || key >= STR_SLP_LIST_MAX) {
 457                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 458                 return ret;
 459         }
 460
 461         VconfNode result;
 462         g_stable[key].value.c = value;
 463         ret = set_vconf(g_stable[key], &result);
 464         g_stable[key].value.c = "";
 465
 466         SETTING_TRACE("setting_set_str ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.c);
 467         *err = ret;
 468         return ret;
 469 }
 470
 471 /** @todo don't use i18n string directly. */
 472 static const setting_lang_entry lang_table[] = {
 473         {       "auto",                 "Automatic"},
 474         {       "ko_KR.UTF-8",  "한국어"},
 475         {       "en_US.UTF-8",  "English"},
 476         {       "zh_CN.UTF-8",  "简体中文"},
 477         {       "zh_HK.UTF-8",  "繁體中文(香港)"},
 478         {       "zh_TW.UTF-8",  "繁體中文(台灣)"},
 479         {       "de_DE.UTF-8",  "Deutsch"},
 480         {       "nl_NL.UTF-8",  "Nederlands"},
 481         {       "es_ES.UTF-8",  "Español"},
 482         {       "pt_PT.UTF-8",  "Português"},
 483         {       "el_GR.UTF-8",  "Eλληνικά"},
 484         {       "it_IT.UTF-8",  "Italiano"},
 485         {       "fr_FR.UTF-8",  "Français"},
 486         {       "tr_TR.UTF-8",  "Türkçe"},
 487         {       "ja_JP.UTF-8",  "にほんご"},
 488         {       "ru_RU.UTF-8",  "Россию"},
 489 };
 490
 491 setting_lang_entry* setting_get_language_table()
 492 {
 493         return (setting_lang_entry*)lang_table;
 494 }
 495
 496
 497 #define LANGLIST_FILE_DIR_PATH  "/opt/data/setting/"
 498 #define LANGLIST_FILE_PATH              LANGLIST_FILE_DIR_PATH"langlist.xml"
 499
 500 static void _parseLangListXML(char* docname);   // internal
 501 static void __tree_walk_langlist(xmlNodePtr cur); // internal
 502
 503 static Eina_List* s_langlist;                                   // internal
 504
 505 // do it once
 506 int _langlist_load()
 507 {
 508         SETTING_TRACE_BEGIN;
 509
 510         if (!s_langlist)
 511         {
 512                 _parseLangListXML(LANGLIST_FILE_PATH);
 513         }
 514
 515         return 0;
 516 }
 517
 518 // singleton
 519 Eina_List* setting_get_language_list()
 520 {
 521         if (NULL == s_langlist)
 522         {
 523                 _langlist_load();
 524         }
 525
 526         return s_langlist;
 527 }
 528
 529 int _langlist_destroy()
 530 {
 531         SETTING_TRACE_BEGIN;
 532     Eina_List *li = s_langlist;
 533         setting_lang_entry* node;
 534     while (li) {
 535         node = (setting_lang_entry*) eina_list_data_get(li);
 536         if (node)
 537         {
 538                                 SETTING_TRACE("destroy nodes : locale : %s title : %s", node->locale, node->title);
 539                                 G_FREE(node->locale);
 540                                 G_FREE(node->title);
 541                                 FREE(node);
 542         }
 543         li = eina_list_next(li);
 544     }
 545         s_langlist = eina_list_free(s_langlist);                // returns NULL
 546
 547         return 0;
 548 }
 549
 550 void  setting_get_language_list_destroy()
 551 {
 552         _langlist_destroy();
 553 }
 554
 555 static void _parseLangListXML(char* docname)
 556 {
 557         SETTING_TRACE_BEGIN;
 558     xmlDocPtr doc;
 559     xmlNodePtr cur;
 560
 561     doc = xmlParseFile(docname);
 562
 563     if (doc == NULL ) {
 564         fprintf(stderr,"Document not parsed successfully. \n");
 565         return;
 566     }
 567
 568     cur = xmlDocGetRootElement(doc);
 569     if (cur == NULL) {
 570         fprintf(stderr,"empty document\n");
 571         xmlFreeDoc(doc);
 572         return;
 573     }
 574
 575     printf("ROOT NODE : %s \n", cur->name);
 576     // make sure root node is "settings"
 577     if (xmlStrcmp(cur->name, (const xmlChar *) "langlist")) {
 578         SETTING_TRACE("document of the wrong type, root node != settings");
 579         xmlFreeDoc(doc);
 580         return;
 581     }
 582
 583     cur = cur->xmlChildrenNode;
 584     __tree_walk_langlist(cur);
 585
 586     /* save tree to file */
 587     if (doc != NULL) {
 588         //xmlSaveFormatFile (docname, doc, 1);
 589         xmlFreeDoc(doc);
 590     }
 591     //xmlFreeDoc(doc);
 592     return;
 593 }
 594
 595 static void __tree_walk_langlist(xmlNodePtr cur)
 596 {
 597         SETTING_TRACE_BEGIN;
 598     xmlNode *cur_node = NULL;
 599         char* id;
 600         char* string;
 601         int number;
 602
 603     for (cur_node = cur; cur_node;cur_node = cur_node->next) {
 604         if (cur_node->type == XML_ELEMENT_NODE) {
 605
 606             SETTING_TRACE(" name=%s title=%s number=%s \n", xmlGetProp(cur_node, (const xmlChar *)"id"), xmlGetProp(cur_node, (const xmlChar *)"string"), xmlGetProp(cur_node, (const xmlChar *)"no"));
 607                         id = (char *)g_strdup((char*)xmlGetProp(cur_node, (const xmlChar *)"id"));
 608                         string = (char *)g_strdup((char*) xmlGetProp(cur_node, (const xmlChar *)"string"));
 609                         number = atoi((char*) xmlGetProp(cur_node, (const xmlChar *)"no"));
 610                         SETTING_TRACE(">>>> locale: %s title: %s", (char*)id, (char*)string);
 611
 612                         setting_lang_entry* pitem = (setting_lang_entry*)calloc(1, sizeof(setting_lang_entry));
 613                         pitem->locale = id;
 614                         pitem->title = string;
 615                         pitem->number = number;
 616
 617                         s_langlist = eina_list_append(s_langlist, pitem);
 618         }
 619     }
 620 }
 621 //-----------------------------------------------------------------------------------------------
 622 //-----------------------------------------------------------------------------------------------
 623
 624 //setting_lang_entry*
 625
 626 //////////////////////////////////////////////////////////////////////////////////////////
 627 int setting_store_init_password(char *in)
 628 {
 629
 630         SHA256_CTX context;
 631         char md[SHA256_DIGEST_LENGTH] = {0,};
 632         /* int i = 0; */
 633         int ret = SETTING_RETURN_FAIL;
 634
 635         SHA256_Init(&context);
 636         SHA256_Update(&context, (char *)in, strlen(in));
 637         SHA256_Final((unsigned char *)md, &context);
 638
 639 #ifdef DEBUG
 640         SETTING_TRACE("input: [%s]\n", in);
 641         SETTING_TRACE("output: [");
 642         for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
 643                 SETTING_TRACE("%02x", md[i]);
 644         SETTING_TRACE("]\n");
 645 #endif
 646
 647         /*  create a file or store a data */
 648         /*  store_password */
 649         FILE *fp = NULL;
 650         int ret_fw = 0;
 651         fp = fopen(PWD_FILE, "w+");
 652         if (fp) {
 653                 ret_fw = fwrite(md, 1, SHA256_DIGEST_LENGTH, fp);
 654                 SETTING_TRACE_DEBUG("fwrite() wrote %d chars.", ret_fw);
 655                 if(ret_fw == SHA256_DIGEST_LENGTH)
 656                 {
 657                         fflush(fp);
 658                         fsync(fp->_fileno);
 659                         ret = SETTING_RETURN_SUCCESS;
 660                 }
 661                 fclose(fp);
 662         } else {
 663                 SETTING_TRACE("ERR: pwd file is not exist \n");
 664         }
 665
 666         return ret;
 667 }
 668
 669 int setting_read_password(char *md_result)
 670 {
 671         SETTING_TRACE_BEGIN;
 672         /* int i; */
 673         FILE *fp = NULL;
 674         fp = fopen(PWD_FILE, "r");
 675         if (fp) {
 676                 int size = fread(md_result, sizeof(char), SHA256_DIGEST_LENGTH, fp);
 677                 if (size != SHA256_DIGEST_LENGTH) {
 678                         SETTING_TRACE_ERROR("fread failed");
 679                 }
 680                 fclose(fp);
 681         } else {
 682                 SETTING_TRACE("ERR: pwd file is not exist \n");
 683                 return SETTING_RETURN_FAIL;
 684         }
 685
 686 #ifdef DEBUG
 687         SETTING_TRACE("output from file: [");
 688         for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
 689                 SETTING_TRACE("%02x", md_result[i]);
 690         SETTING_TRACE("]\n");
 691 #endif
 692         SETTING_TRACE_END;
 693         return 0;
 694 }
 695
 696 int setting_compare_password(char *md_result, const char *in_later)
 697 {
 698         SETTING_TRACE_BEGIN;
 699         SHA256_CTX context_later;
 700         char md_later[SHA256_DIGEST_LENGTH];
 701         int ret = SETTING_RETURN_FAIL;
 702
 703         SHA256_Init(&context_later);
 704         SHA256_Update(&context_later, (char *)in_later, strlen(in_later));
 705         SHA256_Final((unsigned char *)md_later, &context_later);
 706
 707         SETTING_TRACE(" :[ %25s ]", in_later);
 708
 709         if (0 == memcmp(md_later, md_result, SHA256_DIGEST_LENGTH)) {
 710                 SETTING_TRACE("two passwords are same \n");
 711                 ret = 0;
 712         } else {
 713                 SETTING_TRACE("two passwords are different \n");
 714         }
 715         return ret;
 716 }
 717
 718 void setting_destory_listen_list(Eina_List **listened_list)
 719 {
 720         if (listened_list && *listened_list)
 721         {
 722                 Vconf_Change_Node *node = NULL;
 723                 Eina_List *li = *listened_list;
 724                 while (li) {
 725                         node = (Vconf_Change_Node *) eina_list_data_get(li);
 726                         if (node)
 727                         {
 728                                 SETTING_TRACE("Deregister callback[%p] of %s", node->cb, node->in_key);
 729                                 if (node->in_key && node->cb) {
 730                                         (void)vconf_ignore_key_changed(node->in_key, node->cb);
 731                                         FREE(node);
 732                                 }
 733                         }
 734                         li = eina_list_next(li);
 735                 }
 736                 *listened_list = eina_list_free(*listened_list);
 737         }
 738 }
 739
 740 bool setting_add_listen_node(Eina_List **listened_list,const char *vconf, vconf_callback_fn cb, void *data)
 741 {
 742         Vconf_Change_Node *node = calloc(1, sizeof(Vconf_Change_Node));
 743         bool ret = TRUE;
 744         if (node && vconf && cb)
 745         {
 746                 node->in_key = vconf;
 747                 node->cb = cb;
 748                 node->cb_data = data;
 749
 750                 if(0 == vconf_notify_key_changed(vconf, cb, data))
 751                 {
 752                         SETTING_TRACE("Register callback[%p] of %s", node->cb, node->in_key);
 753                         *listened_list = eina_list_append(*listened_list, node);
 754                 }
 755                 else
 756                 {
 757                         SETTING_TRACE_ERROR("Failed to register callback[%p] of %s", node->cb, node->in_key);
 758                         ret = FALSE;
 759                 }
 760         }
 761         return ret;
 762 }
 763
 764