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