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         return ret;
 358 }
 359
 360 int setting_get_bool_slp_key(setting_bool_slp_list key, int *value, int *err)
 361 {
 362         //SETTING_TRACE_BEGIN;
 363         int ret = SETTING_RETURN_FAIL;
 364
 365         /* error check */
 366         if (key < 0 || key >= SETTING_BOOL_SLP_LIST_MAX) {
 367                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 368                 SETTING_TRACE_ERROR(" <<<<<<<< key is invalid >>>>>>>>>>>>> ");
 369                 return ret;
 370         }
 371         VconfNode result;
 372         ret = get_vconf(g_btable[key], &result);
 373         //*value = g_btable[key].value.b;
 374         *value = result.value.b;
 375         return ret;
 376 }
 377
 378 int setting_set_int_slp_key(setting_int_slp_list key, int value, int *err)
 379 {
 380         //SETTING_TRACE_BEGIN;
 381         int ret = SETTING_RETURN_FAIL;
 382
 383         /* error check */
 384         if (key < 0 || key >= SETTING_INT_SLP_LIST_MAX) {
 385                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 386                 SETTING_TRACE(">>> key is invalid ");
 387                 return ret;
 388         }
 389
 390         VconfNode result;
 391         g_itable[key].value.i = value;
 392         ret = set_vconf(g_itable[key],&result);
 393         *err = ret;
 394         SETTING_TRACE("setting_set_int ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.i);
 395         return ret;
 396 }
 397
 398 /* return -1: fail  cannot use err to check the result, return value instead*/
 399 int setting_get_int_slp_key(setting_int_slp_list key, int *value, int *err)
 400 {
 401         //SETTING_TRACE_BEGIN;
 402         int ret = SETTING_RETURN_FAIL;
 403
 404         /* error check */
 405         if (key < 0 || key >= SETTING_INT_SLP_LIST_MAX) {
 406                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 407                 return ret;
 408         }
 409
 410         VconfNode result;
 411         ret = get_vconf(g_itable[key], &result);
 412         //*value = g_itable[key].value.i;
 413         *value = result.value.i;
 414
 415         *err = ret;
 416         return ret;
 417 }
 418
 419 int setting_get_string_slp_key(setting_str_slp_list key, char *value, int *err)
 420 {
 421         //SETTING_TRACE_BEGIN;
 422         int ret = SETTING_RETURN_FAIL;
 423
 424         /* error check */
 425         if (key < 0 || key >= STR_SLP_LIST_MAX || NULL == value) {
 426                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 427                 return ret;
 428         }
 429
 430         /** @todo check memory leack when passwork checking */
 431         VconfNode result;
 432         ret = get_vconf(g_stable[key], &result);
 433
 434         if (ret >= 0)
 435         {
 436                 safeCopyStr(value, result.value.c, strlen(result.value.c));
 437                 SETTING_TRACE(">>>>>>>> %s <<<<<<<<", value);
 438                 FREE(result.value.c);
 439         } else {
 440                 SETTING_TRACE("get_vconf is failed");
 441         }
 442         *err = ret;
 443         return ret;
 444 }
 445
 446 int setting_set_string_slp_key(setting_str_slp_list key, char *value, int *err)
 447 {
 448         int ret = SETTING_RETURN_FAIL;
 449
 450         /* error check */
 451         if (key < 0 || key >= STR_SLP_LIST_MAX) {
 452                 *err = SETTING_GENERAL_ERR_WRONG_PARAMETER;
 453                 return ret;
 454         }
 455
 456         VconfNode result;
 457         g_stable[key].value.c = value;
 458         ret = set_vconf(g_stable[key], &result);
 459         g_stable[key].value.c = "";
 460
 461         SETTING_TRACE("setting_set_str ::: KEY:%d VCONF_KEY=%s TYPE=%d VALUE=%d ", result.key, result.vconf_key, result.type, result.value.c);
 462         *err = ret;
 463         return ret;
 464 }
 465
 466 /** @todo don't use i18n string directly. */
 467 static const setting_lang_entry lang_table[] = {
 468         {       "auto",                 "Automatic"},
 469         {       "ko_KR.UTF-8",  "한국어"},
 470         {       "en_US.UTF-8",  "English"},
 471         {       "zh_CN.UTF-8",  "简体中文"},
 472         {       "zh_HK.UTF-8",  "繁體中文(香港)"},
 473         {       "zh_TW.UTF-8",  "繁體中文(台灣)"},
 474         {       "de_DE.UTF-8",  "Deutsch"},
 475         {       "nl_NL.UTF-8",  "Nederlands"},
 476         {       "es_ES.UTF-8",  "Español"},
 477         {       "pt_PT.UTF-8",  "Português"},
 478         {       "el_GR.UTF-8",  "Eλληνικά"},
 479         {       "it_IT.UTF-8",  "Italiano"},
 480         {       "fr_FR.UTF-8",  "Français"},
 481         {       "tr_TR.UTF-8",  "Türkçe"},
 482         {       "ja_JP.UTF-8",  "にほんご"},
 483         {       "ru_RU.UTF-8",  "Россию"},
 484 };
 485
 486 setting_lang_entry* setting_get_language_table()
 487 {
 488         return (setting_lang_entry*)lang_table;
 489 }
 490
 491
 492 #define LANGLIST_FILE_DIR_PATH  "/opt/data/setting/"
 493 #define LANGLIST_FILE_PATH              LANGLIST_FILE_DIR_PATH"langlist.xml"
 494
 495 static void _parseLangListXML(char* docname);   // internal
 496 static void __tree_walk_langlist(xmlNodePtr cur); // internal
 497
 498 static Eina_List* s_langlist;                                   // internal
 499
 500 // do it once
 501 int _langlist_load()
 502 {
 503         SETTING_TRACE_BEGIN;
 504
 505         if (!s_langlist)
 506         {
 507                 _parseLangListXML(LANGLIST_FILE_PATH);
 508         }
 509
 510         return 0;
 511 }
 512
 513 // singleton
 514 Eina_List* setting_get_language_list()
 515 {
 516         if (NULL == s_langlist)
 517         {
 518                 _langlist_load();
 519         }
 520
 521         return s_langlist;
 522 }
 523
 524 int _langlist_destroy()
 525 {
 526         SETTING_TRACE_BEGIN;
 527     Eina_List *li = s_langlist;
 528         setting_lang_entry* node;
 529     while (li) {
 530         node = (setting_lang_entry*) eina_list_data_get(li);
 531         if (node)
 532         {
 533                                 SETTING_TRACE("destroy nodes : locale : %s title : %s", node->locale, node->title);
 534                                 G_FREE(node->locale);
 535                                 G_FREE(node->title);
 536                                 FREE(node);
 537         }
 538         li = eina_list_next(li);
 539     }
 540         s_langlist = eina_list_free(s_langlist);                // returns NULL
 541
 542         return 0;
 543 }
 544
 545 void  setting_get_language_list_destroy()
 546 {
 547         _langlist_destroy();
 548 }
 549
 550 static void _parseLangListXML(char* docname)
 551 {
 552         SETTING_TRACE_BEGIN;
 553     xmlDocPtr doc;
 554     xmlNodePtr cur;
 555
 556     doc = xmlParseFile(docname);
 557
 558     if (doc == NULL ) {
 559         fprintf(stderr,"Document not parsed successfully. \n");
 560         return;
 561     }
 562
 563     cur = xmlDocGetRootElement(doc);
 564     if (cur == NULL) {
 565         fprintf(stderr,"empty document\n");
 566         xmlFreeDoc(doc);
 567         return;
 568     }
 569
 570     printf("ROOT NODE : %s \n", cur->name);
 571     // make sure root node is "settings"
 572     if (xmlStrcmp(cur->name, (const xmlChar *) "langlist")) {
 573         SETTING_TRACE("document of the wrong type, root node != settings");
 574         xmlFreeDoc(doc);
 575         return;
 576     }
 577
 578     cur = cur->xmlChildrenNode;
 579     __tree_walk_langlist(cur);
 580
 581     /* save tree to file */
 582     if (doc != NULL) {
 583         //xmlSaveFormatFile (docname, doc, 1);
 584         xmlFreeDoc(doc);
 585     }
 586     //xmlFreeDoc(doc);
 587     return;
 588 }
 589
 590 static void __tree_walk_langlist(xmlNodePtr cur)
 591 {
 592         SETTING_TRACE_BEGIN;
 593     xmlNode *cur_node = NULL;
 594         char* id;
 595         char* string;
 596         int number;
 597
 598     for (cur_node = cur; cur_node;cur_node = cur_node->next) {
 599         if (cur_node->type == XML_ELEMENT_NODE) {
 600
 601             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"));
 602                         id = (char *)g_strdup((char*)xmlGetProp(cur_node, (const xmlChar *)"id"));
 603                         string = (char *)g_strdup((char*) xmlGetProp(cur_node, (const xmlChar *)"string"));
 604                         number = atoi((char*) xmlGetProp(cur_node, (const xmlChar *)"no"));
 605                         SETTING_TRACE(">>>> locale: %s title: %s", (char*)id, (char*)string);
 606
 607                         setting_lang_entry* pitem = (setting_lang_entry*)calloc(1, sizeof(setting_lang_entry));
 608                         pitem->locale = id;
 609                         pitem->title = string;
 610                         pitem->number = number;
 611
 612                         s_langlist = eina_list_append(s_langlist, pitem);
 613         }
 614     }
 615 }
 616 //-----------------------------------------------------------------------------------------------
 617 //-----------------------------------------------------------------------------------------------
 618
 619 //setting_lang_entry*
 620
 621 //////////////////////////////////////////////////////////////////////////////////////////
 622 int setting_store_init_password(char *in)
 623 {
 624
 625         SHA256_CTX context;
 626         char md[SHA256_DIGEST_LENGTH] = {0,};
 627         /* int i = 0; */
 628         int ret = SETTING_RETURN_FAIL;
 629
 630         SHA256_Init(&context);
 631         SHA256_Update(&context, (char *)in, strlen(in));
 632         SHA256_Final((unsigned char *)md, &context);
 633
 634 #ifdef DEBUG
 635         SETTING_TRACE("input: [%s]\n", in);
 636         SETTING_TRACE("output: [");
 637         for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
 638                 SETTING_TRACE("%02x", md[i]);
 639         SETTING_TRACE("]\n");
 640 #endif
 641
 642         /*  create a file or store a data */
 643         /*  store_password */
 644         FILE *fp = NULL;
 645         int ret_fw = 0;
 646         fp = fopen(PWD_FILE, "w+");
 647         if (fp) {
 648                 ret_fw = fwrite(md, 1, SHA256_DIGEST_LENGTH, fp);
 649                 SETTING_TRACE_DEBUG("fwrite() wrote %d chars.", ret_fw);
 650                 if(ret_fw == SHA256_DIGEST_LENGTH)
 651                 {
 652                         fflush(fp);
 653                         fsync(fp->_fileno);
 654                         ret = SETTING_RETURN_SUCCESS;
 655                 }
 656                 fclose(fp);
 657         } else {
 658                 SETTING_TRACE("ERR: pwd file is not exist \n");
 659         }
 660
 661         return ret;
 662 }
 663
 664 int setting_read_password(char *md_result)
 665 {
 666         SETTING_TRACE_BEGIN;
 667         /* int i; */
 668         FILE *fp = NULL;
 669         fp = fopen(PWD_FILE, "r");
 670         if (fp) {
 671                 int size = fread(md_result, sizeof(char), SHA256_DIGEST_LENGTH, fp);
 672                 if (size != SHA256_DIGEST_LENGTH) {
 673                         SETTING_TRACE_ERROR("fread failed");
 674                 }
 675                 fclose(fp);
 676         } else {
 677                 SETTING_TRACE("ERR: pwd file is not exist \n");
 678                 return SETTING_RETURN_FAIL;
 679         }
 680
 681 #ifdef DEBUG
 682         SETTING_TRACE("output from file: [");
 683         for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
 684                 SETTING_TRACE("%02x", md_result[i]);
 685         SETTING_TRACE("]\n");
 686 #endif
 687         SETTING_TRACE_END;
 688         return 0;
 689 }
 690
 691 int setting_compare_password(char *md_result, const char *in_later)
 692 {
 693         SETTING_TRACE_BEGIN;
 694         SHA256_CTX context_later;
 695         char md_later[SHA256_DIGEST_LENGTH];
 696         int ret = SETTING_RETURN_FAIL;
 697
 698         SHA256_Init(&context_later);
 699         SHA256_Update(&context_later, (char *)in_later, strlen(in_later));
 700         SHA256_Final((unsigned char *)md_later, &context_later);
 701
 702         SETTING_TRACE(" :[ %25s ]", in_later);
 703
 704         if (0 == memcmp(md_later, md_result, SHA256_DIGEST_LENGTH)) {
 705                 SETTING_TRACE("two passwords are same \n");
 706                 ret = 0;
 707         } else {
 708                 SETTING_TRACE("two passwords are different \n");
 709         }
 710         return ret;
 711 }
 712
 713 void setting_destory_listen_list(Eina_List **listened_list)
 714 {
 715         if (listened_list && *listened_list)
 716         {
 717                 Vconf_Change_Node *node = NULL;
 718                 Eina_List *li = *listened_list;
 719                 while (li) {
 720                         node = (Vconf_Change_Node *) eina_list_data_get(li);
 721                         if (node)
 722                         {
 723                                 //SETTING_TRACE("Deregister callback[%p] of %s", node->cb, node->in_key);
 724                                 if (node->in_key && node->cb) {
 725                                         (void)vconf_ignore_key_changed(node->in_key, node->cb);
 726                                         FREE(node);
 727                                 }
 728                         }
 729                         li = eina_list_next(li);
 730                 }
 731                 *listened_list = eina_list_free(*listened_list);
 732         }
 733 }
 734
 735 bool setting_add_listen_node(Eina_List **listened_list,const char *vconf, vconf_callback_fn cb, void *data)
 736 {
 737         Vconf_Change_Node *node = calloc(1, sizeof(Vconf_Change_Node));
 738         bool ret = TRUE;
 739         if (node && vconf && cb)
 740         {
 741                 node->in_key = vconf;
 742                 node->cb = cb;
 743                 node->cb_data = data;
 744
 745                 if(0 == vconf_notify_key_changed(vconf, cb, data))
 746                 {
 747                         //SETTING_TRACE("Register callback[%p] of %s", node->cb, node->in_key);
 748                         *listened_list = eina_list_append(*listened_list, node);
 749                 }
 750                 else
 751                 {
 752                         SETTING_TRACE_ERROR("Failed to register callback[%p] of %s", node->cb, node->in_key);
 753                         ret = FALSE;
 754                 }
 755         }
 756         return ret;
 757 }
 758
 759