Sync with tizen 2.4.submit/tizen/20150727.102911accepted/tizen/wearable/20150727.235951accepted/tizen/tv/20150727.235853accepted/tizen/mobile/20150727.235803

1. To use the POSIX portable file name(base64 encode/decode)
2. Use keynode for interface of internal api.

Change-Id: I1336ce86f0f794ff2253ab70edd3c47cfb25840a
Signed-off-by: Myungki Lee <mk5004.lee@samsung.com>

3 files changed, 304 insertions, 177 deletions

diff --git a/include/app_preference_internal.h b/include/app_preference_internal.h
index 8108903..cb670fe 100755
--- a/include/app_preference_internal.h
+++ b/include/app_preference_internal.h
@@ -23,6 +23,7 @@ extern "C" {
 #endif
 
 #include "app_preference_log.h"
+#include "linux/limits.h"
 
 #define BUF_LEN			(4096)
 #define PREF_DIR	".pref/"
@@ -36,6 +37,15 @@ extern "C" {
 #define PREF_F_TYPE_NAME	"pref_type"
 #define PREF_F_DATA_NAME	"pref_data"
 
+/* ASCII VALUE */
+#define PREF_KEYNAME_C_PAD '='
+#define PREF_KEYNAME_C_PLUS '+'
+#define PREF_KEYNAME_C_SLASH '/'
+
+#define PREF_KEYNAME_C_DOT '.'
+#define PREF_KEYNAME_C_UNDERSCORE '_'
+#define PREF_KEYNAME_C_HYPHEN '-'
+
 /**
  * @brief Definition for PREFERENCE_ERROR_WRONG_PREFIX.
  */
@@ -122,11 +132,11 @@ typedef struct _keylist_t {
 
 
 int _preference_kdb_add_notify
-	(const char *keyname, preference_changed_cb cb, void *data);
+	(keynode_t *keynode, preference_changed_cb cb, void *data);
 int _preference_kdb_del_notify
-	(const char *keyname);
+	(keynode_t *keynode);
 
-int _preference_get_key_path(const char *keyname, char *path);
+int _preference_get_key_path(keynode_t *keynode, char *path);
 int _preference_get_key(keynode_t *keynode);
 
 int _preference_keynode_set_keyname(keynode_t *keynode, const char *keyname);
diff --git a/preference/preference.c b/preference/preference.c
index c19b641..8ae6dd5 100644
--- a/preference/preference.c
+++ b/preference/preference.c
@@ -25,11 +25,15 @@
 #include <ctype.h>
 #include <string.h>
 #include <execinfo.h>
+#include <glib.h>
 
 #include <app_preference.h>
 #include <app_preference_internal.h>
 #include <app_common.h>
 
+#include <sys/syscall.h>
+
+
 #ifndef API
 #define API __attribute__ ((visibility("default")))
 #endif
@@ -43,7 +47,6 @@ static int g_posix_errno;
 static int g_preference_errno;
 static char *g_pref_dir_path = NULL;
 
-
 enum preference_op_t {
     PREFERENCE_OP_GET = 0,
     PREFERENCE_OP_SET = 1
@@ -82,16 +85,16 @@ char* _preference_get_pref_dir_path()
 {
 	char *app_data_path = NULL;
 
-	if (!g_pref_dir_path)
-	{
+	if (!g_pref_dir_path) {
 		g_pref_dir_path = (char *)malloc(PREFERENCE_KEY_PATH_LEN + 1);
-		if ((app_data_path = app_get_data_path()) == NULL)
-		{
+
+		if ((app_data_path = app_get_data_path()) == NULL) {
 			ERR("IO_ERROR(0x%08x) : fail to get data directory", PREFERENCE_ERROR_IO_ERROR);
 			free(g_pref_dir_path);
 			g_pref_dir_path = NULL;
 			return NULL;
 		}
+
 		snprintf(g_pref_dir_path, PREFERENCE_KEY_PATH_LEN, "%s%s", app_data_path, PREF_DIR);
 		INFO("pref_dir_path: %s", g_pref_dir_path);
 		free(app_data_path);
@@ -152,61 +155,79 @@ inline void _preference_keynode_free(keynode_t *keynode)
 
 int _preference_get_key_name(const char *keyfile, char *keyname)
 {
-	char convert_key[PREFERENCE_KEY_PATH_LEN] = {0,};
-	char *chrptr = NULL;
+	unsigned int i = 0;
+	char convert_key[PATH_MAX] = {0,};
+	guchar *key_name = NULL;
+	gsize key_path_len = 0;
 
-	strncpy(convert_key, keyfile, strlen(keyfile));
+	strncpy(convert_key, keyfile, PATH_MAX - 1);
 
-	chrptr = strchr((const char*)convert_key, DELIMITER);
-	if(chrptr) {
-		chrptr = strchr((const char*)convert_key, DELIMITER);
-		while(chrptr) {
-			convert_key[chrptr-convert_key] = '/';
-			chrptr = strchr((const char*)chrptr+1, DELIMITER);
+	for (i = 0; i < strlen(convert_key); i++) {
+		switch (convert_key[i]) {
+		case PREF_KEYNAME_C_DOT:
+			convert_key[i] = PREF_KEYNAME_C_PAD;
+			break;
+		case PREF_KEYNAME_C_UNDERSCORE:
+			convert_key[i] = PREF_KEYNAME_C_PLUS;
+			break;
+		case PREF_KEYNAME_C_HYPHEN:
+			convert_key[i] = PREF_KEYNAME_C_SLASH;
+			break;
+		default:
+			break;
 		}
 	}
-	snprintf(keyname, PREFERENCE_KEY_PATH_LEN, "%s", (const char*)convert_key);
+
+	key_name = g_base64_decode((const gchar *)convert_key, &key_path_len);
+	snprintf(keyname, PREFERENCE_KEY_PATH_LEN-1, "%s", key_name);
+	free(key_name);
 
 	return PREFERENCE_ERROR_NONE;
 }
 
-
-int _preference_get_key_path(const char *keyname, char *path)
+int _preference_get_key_path(keynode_t *keynode, char *path)
 {
+	unsigned int i = 0;
 	const char *key = NULL;
+	char *keyname = keynode->keyname;
 
-	if(!keyname) {
+	if (!keyname) {
 		ERR("keyname is null");
 		return PREFERENCE_ERROR_WRONG_PREFIX;
 	}
 
-	char convert_key[PREFERENCE_KEY_PATH_LEN] = {0,};
-	char *chrptr = NULL;
+	char *convert_key = NULL;
 	char *pref_dir_path = NULL;
 
-	strncpy(convert_key, keyname, strlen(keyname));
+	convert_key = g_base64_encode((const guchar *)keyname, strlen(keyname));
 
 	pref_dir_path = _preference_get_pref_dir_path();
-	if (!pref_dir_path)
-	{
+	if (!pref_dir_path) {
 		LOGE("_preference_get_pref_dir_path() failed.");
+		g_free(convert_key);
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 
-	chrptr = strchr((const char*)convert_key, (int)'/');
-	if(!chrptr)	{
-		key = (const char*)convert_key;
-	}
-	else {
-		chrptr = strchr((const char*)convert_key, (int)'/');
-		while(chrptr) {
-			convert_key[chrptr-convert_key] = DELIMITER;
-			chrptr = strchr((const char*)chrptr+1, (int)'/');
+	for (i = 0; i < strlen(convert_key); i++) {
+		switch (convert_key[i]) {
+		case PREF_KEYNAME_C_PAD:
+			convert_key[i] = PREF_KEYNAME_C_DOT;
+			break;
+		case PREF_KEYNAME_C_PLUS:
+			convert_key[i] = PREF_KEYNAME_C_UNDERSCORE;
+			break;
+		case PREF_KEYNAME_C_SLASH:
+			convert_key[i] = PREF_KEYNAME_C_HYPHEN;
+			break;
+		default:
+			break;
 		}
-		key = (const char*)convert_key;
 	}
 
-	snprintf(path, PREFERENCE_KEY_PATH_LEN, "%s%s", pref_dir_path, key);
+	key = (const char*)convert_key;
+
+	snprintf(path, PATH_MAX-1, "%s%s", pref_dir_path, key);
+	g_free(convert_key);
 
 	return PREFERENCE_ERROR_NONE;
 }
@@ -217,16 +238,13 @@ static int _preference_set_key_check_pref_dir()
 	mode_t dir_mode = 0664 | 0111;
 
 	pref_dir_path = _preference_get_pref_dir_path();
-	if (!pref_dir_path)
-	{
+	if (!pref_dir_path) {
 		LOGE("_preference_get_pref_dir_path() failed.");
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 
-	if (access(pref_dir_path, F_OK) < 0)
-	{
-		if (mkdir(pref_dir_path, dir_mode) < 0)
-		{
+	if (access(pref_dir_path, F_OK) < 0) {
+		if (mkdir(pref_dir_path, dir_mode) < 0) {
 			ERR("mkdir() failed(%d/%s)", errno, strerror(errno));
 			return PREFERENCE_ERROR_IO_ERROR;
 		}
@@ -242,6 +260,7 @@ static int _preference_set_key_creation(const char* path)
 	temp = umask(0000);
 	fd = open(path, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
 	umask(temp);
+
 	if(fd == -1) {
 		ERR("open(rdwr,create) error: %d(%s)", errno, strerror(errno));
 		return PREFERENCE_ERROR_IO_ERROR;
@@ -299,6 +318,34 @@ static int _preference_set_unlock(int fd)
 	return _preference_set_file_lock(fd, F_UNLCK);
 }
 
+static void _preference_log_subject_label(void)
+{
+	int fd;
+	int ret;
+	char smack_label[256] = {0,};
+	char curren_path[256] = {0,};
+	int tid;
+
+	tid = (int)syscall(SYS_gettid);
+	snprintf(curren_path, sizeof(curren_path)-1, "/proc/%d/attr/current", tid);
+	fd = open(curren_path, O_RDONLY);
+	if (fd < 0) {
+		LOGE("fail to open self current attr (err: %s)", strerror(errno));
+		return;
+	}
+
+	ret = read(fd, smack_label, sizeof(smack_label)-1);
+	if (ret < 0) {
+		close(fd);
+		LOGE("fail to open self current attr (err: %s)", strerror(errno));
+		return;
+	}
+
+	ERR("current(%d) subject label : %s", tid, smack_label);
+
+	close(fd);
+}
+
 static int _preference_check_retry_err(keynode_t *keynode, int preference_errno, int io_errno, int op_type)
 {
 	int is_busy_err = 0;
@@ -312,22 +359,25 @@ static int _preference_check_retry_err(keynode_t *keynode, int preference_errno,
 				if(op_type == PREFERENCE_OP_SET)
 				{
 					int rc = 0;
-					char path[PREFERENCE_KEY_PATH_LEN] = {0,};
-					rc = _preference_get_key_path(keynode->keyname, path);
+					char path[PATH_MAX] = {0,};
+					rc = _preference_get_key_path(keynode, path);
 					if (rc != PREFERENCE_ERROR_NONE) {
 						ERR("_preference_get_key_path error");
+						_preference_log_subject_label();
 						break;
 					}
 
 					rc = _preference_set_key_check_pref_dir();
 					if (rc != PREFERENCE_ERROR_NONE) {
 						ERR("_preference_set_key_check_pref_dir() failed.");
+						_preference_log_subject_label();
 						break;
 					}
 
-					preference_errno = _preference_set_key_creation(path);
+					rc = _preference_set_key_creation(path);
 					if (rc != PREFERENCE_ERROR_NONE) {
 						ERR("_preference_set_key_creation error : %s", path);
+						_preference_log_subject_label();
 						break;
 					}
 					INFO("%s key is created", keynode->keyname);
@@ -336,6 +386,11 @@ static int _preference_check_retry_err(keynode_t *keynode, int preference_errno,
 				}
 				break;
 			}
+			case EACCES :
+			{
+				_preference_log_subject_label();
+				break;
+			}
 			case EAGAIN :
 			case EMFILE :
 			case ENFILE :
@@ -411,7 +466,7 @@ static int _preference_check_retry_err(keynode_t *keynode, int preference_errno,
 
 static int _preference_set_key_filesys(keynode_t *keynode, int *io_errno)
 {
-	char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+	char path[PATH_MAX] = {0,};
 	FILE *fp = NULL;
 	int ret = -1;
 	int func_ret = PREFERENCE_ERROR_NONE;
@@ -425,7 +480,7 @@ retry_open :
 	err_no = 0;
 	func_ret = PREFERENCE_ERROR_NONE;
 
-	ret = _preference_get_key_path(keynode->keyname, path);
+	ret = _preference_get_key_path(keynode, path);
 	retv_if(ret != PREFERENCE_ERROR_NONE, ret);
 
 	if( (fp = fopen(path, "r+")) == NULL ) {
@@ -566,13 +621,10 @@ static int _preference_set_key(keynode_t *keynode)
 	char err_buf[100] = { 0, };
 
 	ret = _preference_set_key_filesys(keynode, &io_errno);
-	if (ret == PREFERENCE_ERROR_NONE)
-	{
+	if (ret == PREFERENCE_ERROR_NONE) {
 		g_posix_errno = PREFERENCE_ERROR_NONE;
 		g_preference_errno = PREFERENCE_ERROR_NONE;
-	}
-	else
-	{
+	} else {
 		strerror_r(io_errno, err_buf, 100);
 		ERR("_preference_set_key(%s) step(%d) failed(%d / %s)", keynode->keyname, ret, io_errno, err_buf);
 		g_posix_errno = io_errno;
@@ -601,9 +653,9 @@ API int preference_set_int(const char *key, int intval)
 	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
 	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
-	if(func_ret != PREFERENCE_ERROR_NONE) {
-		_preference_keynode_free(pKeyNode);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
 		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 	_preference_keynode_set_value_int(pKeyNode, intval);
@@ -611,7 +663,7 @@ API int preference_set_int(const char *key, int intval)
 	if (_preference_set_key(pKeyNode) != PREFERENCE_ERROR_NONE) {
 		ERR("preference_set_int(%d) : key(%s/%d) error", getpid(), key, intval);
 		func_ret = PREFERENCE_ERROR_IO_ERROR;
-	} else{
+	} else {
 		INFO("%s(%d) success", key, intval);
 	}
 
@@ -640,9 +692,9 @@ API int preference_set_boolean(const char *key, bool boolval)
 	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
 	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
-	if(func_ret != PREFERENCE_ERROR_NONE) {
-		_preference_keynode_free(pKeyNode);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
 		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 	_preference_keynode_set_value_boolean(pKeyNode, boolval);
@@ -678,9 +730,9 @@ API int preference_set_double(const char *key, double dblval)
 	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
 	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
-	if(func_ret != PREFERENCE_ERROR_NONE) {
-		_preference_keynode_free(pKeyNode);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
 		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 	_preference_keynode_set_value_double(pKeyNode, dblval);
@@ -717,9 +769,9 @@ API int preference_set_string(const char *key, const char *strval)
 	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
 	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
-	if(func_ret != PREFERENCE_ERROR_NONE) {
-		_preference_keynode_free(pKeyNode);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
 		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 	_preference_keynode_set_value_string(pKeyNode, strval);
@@ -740,7 +792,7 @@ API int preference_set_string(const char *key, const char *strval)
 
 static int _preference_get_key_filesys(keynode_t *keynode, int* io_errno)
 {
-	char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+	char path[PATH_MAX] = {0,};
 	int ret = -1;
 	int func_ret = PREFERENCE_ERROR_NONE;
 	char err_buf[100] = { 0, };
@@ -754,7 +806,7 @@ retry_open :
 	errno = 0;
 	func_ret = PREFERENCE_ERROR_NONE;
 
-	ret = _preference_get_key_path(keynode->keyname, path);
+	ret = _preference_get_key_path(keynode, path);
 	retv_if(ret != PREFERENCE_ERROR_NONE, ret);
 
 	if( (fp = fopen(path, "r")) == NULL ) {
@@ -793,7 +845,6 @@ retry :
 		case PREFERENCE_TYPE_INT:
 		{
 			int value_int = 0;
-			int read_size = 0;
 			read_size = fread((void*)&value_int, sizeof(int), 1, fp);
 			if((read_size <= 0) || (read_size > sizeof(int))) {
 				if(!ferror(fp)) {
@@ -811,7 +862,6 @@ retry :
 		case PREFERENCE_TYPE_DOUBLE:
 		{
 			double value_dbl = 0;
-			int read_size = 0;
 			read_size = fread((void*)&value_dbl, sizeof(double), 1, fp);
 			if((read_size <= 0) || (read_size > sizeof(double))) {
 				if(!ferror(fp)) {
@@ -829,7 +879,6 @@ retry :
 		case PREFERENCE_TYPE_BOOLEAN:
 		{
 			int value_int = 0;
-			int read_size = 0;
 			read_size = fread((void*)&value_int, sizeof(int), 1, fp);
 			if((read_size <= 0) || (read_size > sizeof(int))) {
 				if(!ferror(fp)) {
@@ -901,16 +950,11 @@ out_unlock :
 
 
 out_return :
-	if (func_ret != PREFERENCE_ERROR_NONE)
-	{
+	if (func_ret != PREFERENCE_ERROR_NONE) {
 		strerror_r(err_no, err_buf, 100);
 
-		if (_preference_check_retry_err(keynode, func_ret, err_no, PREFERENCE_OP_GET))
-		{
-			if (retry_cnt < PREFERENCE_ERROR_RETRY_CNT)
-			{
-				WARN("_preference_get_key_filesys(%s) step(%d) failed(%d / %s) retry(%d)",
-					keynode->keyname, func_ret, err_no, err_buf, retry_cnt);
+		if (_preference_check_retry_err(keynode, func_ret, err_no, PREFERENCE_OP_GET)) {
+			if (retry_cnt < PREFERENCE_ERROR_RETRY_CNT) {
 				retry_cnt++;
 				usleep((retry_cnt)*PREFERENCE_ERROR_RETRY_SLEEP_UTIME);
 
@@ -919,21 +963,11 @@ out_return :
 				else
 					goto retry_open;
 			}
-			else
-			{
+			else {
 				ERR("_preference_get_key_filesys(%s) step(%d) faild(%d / %s) over the retry count.",
 					keynode->keyname, func_ret, err_no, err_buf);
 			}
 		}
-		else
-		{
-			ERR("_preference_get_key_filesys(%s) step(%d) failed(%d / %s) retry(%d) ",
-				keynode->keyname, func_ret, err_no, err_buf, retry_cnt);
-		}
-	} else {
-		if(retry_cnt > 0) {
-			DBG("preference get filesys ok with retry cnt(%d)", retry_cnt);
-		}
 	}
 
 	if (fp)
@@ -951,12 +985,11 @@ int _preference_get_key(keynode_t *keynode)
 	char err_buf[100] = {0,};
 
 	ret = _preference_get_key_filesys(keynode, &io_errno);
-	if(ret == PREFERENCE_ERROR_NONE) {
+	if (ret == PREFERENCE_ERROR_NONE) {
 		g_posix_errno = PREFERENCE_ERROR_NONE;
 		g_preference_errno = PREFERENCE_ERROR_NONE;
 	}
-	else
-	{
+	else {
 		if (io_errno == ENOENT)
 			ret = PREFERENCE_ERROR_NO_KEY;
 		else
@@ -989,15 +1022,19 @@ API int preference_get_int(const char *key, int *intval)
 	keynode_t* pKeyNode = _preference_keynode_new();
 	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
-	_preference_keynode_set_keyname(pKeyNode, key);
+	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
+		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_IO_ERROR;
+	}
 
 	func_ret = _preference_get_key(pKeyNode);
-
 	if (func_ret != PREFERENCE_ERROR_NONE) {
 		ERR("preference_get_int(%d) : key(%s) error", getpid(), key);
 	} else {
 		*intval = pKeyNode->value.i;
-		if(pKeyNode->type == PREFERENCE_TYPE_INT) {
+		if (pKeyNode->type == PREFERENCE_TYPE_INT) {
 			INFO("%s(%d) success", key, *intval);
 			func_ret = PREFERENCE_ERROR_NONE;
 		} else {
@@ -1030,7 +1067,12 @@ API int preference_get_boolean(const char *key, bool *boolval)
 	keynode_t* pKeyNode = _preference_keynode_new();
 	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
-	_preference_keynode_set_keyname(pKeyNode, key);
+	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
+		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_IO_ERROR;
+	}
 
 	func_ret = _preference_get_key(pKeyNode);
 
@@ -1038,7 +1080,7 @@ API int preference_get_boolean(const char *key, bool *boolval)
 		ERR("preference_get_boolean(%d) : %s error", getpid(), key);
 	} else {
 		*boolval = !!(pKeyNode->value.b);
-		if(pKeyNode->type == PREFERENCE_TYPE_BOOLEAN) {
+		if (pKeyNode->type == PREFERENCE_TYPE_BOOLEAN) {
 			INFO("%s(%d) success", key, *boolval);
 			func_ret = PREFERENCE_ERROR_NONE;
 		} else {
@@ -1071,7 +1113,12 @@ API int preference_get_double(const char *key, double *dblval)
 	keynode_t* pKeyNode = _preference_keynode_new();
 	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
-	_preference_keynode_set_keyname(pKeyNode, key);
+	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
+		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_IO_ERROR;
+	}
 
 	func_ret = _preference_get_key(pKeyNode);
 
@@ -1079,8 +1126,7 @@ API int preference_get_double(const char *key, double *dblval)
 		ERR("preference_get_double(%d) : %s error", getpid(), key);
 	} else {
 		*dblval = pKeyNode->value.d;
-
-		if(pKeyNode->type == PREFERENCE_TYPE_DOUBLE) {
+		if (pKeyNode->type == PREFERENCE_TYPE_DOUBLE) {
 			INFO("%s(%f) success", key, *dblval);
 			func_ret = PREFERENCE_ERROR_NONE;
 		} else {
@@ -1099,7 +1145,8 @@ API int preference_get_double(const char *key, double *dblval)
 /*
  * This function get the string value of given key
  * @param[in]	key	key
- * @return pointer of key value on success, NULL on error
+ * @param[out]	value output buffer
+ * @return 0 on success, -1 on error
  */
 API int preference_get_string(const char *key, char **value)
 {
@@ -1112,16 +1159,20 @@ API int preference_get_string(const char *key, char **value)
 	keynode_t* pKeyNode = _preference_keynode_new();
 	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
-	_preference_keynode_set_keyname(pKeyNode, key);
+	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
+		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_IO_ERROR;
+	}
 
 	char *tempstr = NULL;
-
 	func_ret = _preference_get_key(pKeyNode);
 
 	if (func_ret != PREFERENCE_ERROR_NONE) {
 		ERR("preference_get_string(%d) : %s error", getpid(), key);
 	} else {
-		if(pKeyNode->type == PREFERENCE_TYPE_STRING)
+		if (pKeyNode->type == PREFERENCE_TYPE_STRING)
 			tempstr = pKeyNode->value.s;
 		else {
 			ERR("The type(%d) of keynode(%s) is not STR", pKeyNode->type, pKeyNode->keyname);
@@ -1150,17 +1201,35 @@ API int preference_remove(const char *key)
 {
 	START_TIME_CHECK
 
-	char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+	char path[PATH_MAX] = {0,};
 	int ret = -1;
 	int err_retry = PREFERENCE_ERROR_RETRY_CNT;
 	int func_ret = PREFERENCE_ERROR_NONE;
 
 	retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
 
-	ret = _preference_get_key_path(key, path);
-	retvm_if(ret != PREFERENCE_ERROR_NONE, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is not valid");
+	keynode_t* pKeyNode = _preference_keynode_new();
+	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
+
+	ret = _preference_keynode_set_keyname(pKeyNode, key);
+	if (ret != PREFERENCE_ERROR_NONE) {
+		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_IO_ERROR;
+	}
+
+	ret = _preference_get_key_path(pKeyNode, path);
+	if (ret != PREFERENCE_ERROR_NONE) {
+		ERR("Invalid argument: key is not valid");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_INVALID_PARAMETER;
+	}
 
-	retvm_if(access(path, F_OK) == -1, PREFERENCE_ERROR_NO_KEY, "Error : key(%s) is not exist", key);
+	if (access(path, F_OK) == -1) {
+		ERR("Error : key(%s) is not exist", key);
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_NO_KEY;
+	}
 
 	do {
 		ret = remove(path);
@@ -1173,7 +1242,9 @@ API int preference_remove(const char *key)
 		}
 	} while(err_retry--);
 
-	END_TIME_CHECK
+	END_TIME_CHECK;
+
+	_preference_keynode_free(pKeyNode);
 
 	return func_ret;
 }
@@ -1203,37 +1274,52 @@ API int preference_remove_all(void)
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 
+	keynode_t* pKeyNode = _preference_keynode_new();
+	if (pKeyNode == NULL)
+	{
+		ERR("key malloc fail");
+		closedir(dir);
+		return PREFERENCE_ERROR_OUT_OF_MEMORY;
+	}
+
 	while ((dent = readdir(dir)))
 	{
 		const char *entry = dent->d_name;
 		char keyname[PREFERENCE_KEY_PATH_LEN] = {0,};
-		char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+		char path[PATH_MAX] = {0,};
 
-		if (entry[0] == '.')
-		{
+		if (entry[0] == '.') {
 			continue;
 		}
 
 		ret = _preference_get_key_name(entry, keyname);
-		if (ret != PREFERENCE_ERROR_NONE)
-		{
+		if (ret != PREFERENCE_ERROR_NONE) {
 			ERR("_preference_get_key_name() failed(%d)", ret);
+			_preference_keynode_free(pKeyNode);
 			closedir(dir);
 			return ret;
 		}
 
 		ret = preference_unset_changed_cb(keyname);
-		if (ret != PREFERENCE_ERROR_NONE)
-		{
+		if (ret != PREFERENCE_ERROR_NONE) {
 			ERR("preference_unset_changed_cb() failed(%d)", ret);
+			_preference_keynode_free(pKeyNode);
 			closedir(dir);
 			return PREFERENCE_ERROR_IO_ERROR;
 		}
 
-		ret = _preference_get_key_path(keyname, path);
-		if (ret != PREFERENCE_ERROR_NONE)
-		{
+		ret = _preference_keynode_set_keyname(pKeyNode, keyname);
+		if (ret != PREFERENCE_ERROR_NONE) {
+			ERR("set key name error");
+			_preference_keynode_free(pKeyNode);
+			closedir(dir);
+			return PREFERENCE_ERROR_IO_ERROR;
+		}
+
+		ret = _preference_get_key_path(pKeyNode, path);
+		if (ret != PREFERENCE_ERROR_NONE) {
 			ERR("_preference_get_key_path() failed(%d)", ret);
+			_preference_keynode_free(pKeyNode);
 			closedir(dir);
 			return ret;
 		}
@@ -1251,6 +1337,7 @@ API int preference_remove_all(void)
 		} while(err_retry--);
 	}
 
+	_preference_keynode_free(pKeyNode);
 	closedir(dir);
 
 	END_TIME_CHECK
@@ -1262,27 +1349,39 @@ int preference_is_existing(const char *key, bool *exist)
 {
 	START_TIME_CHECK
 
-	char path[PREFERENCE_KEY_PATH_LEN] = {0,};
+	char path[PATH_MAX] = {0,};
 	int ret = -1;
 	int func_ret = PREFERENCE_ERROR_NONE;
 
 	retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
 	retvm_if(exist == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
 
-	ret = _preference_get_key_path(key, path);
-	retv_if(ret != PREFERENCE_ERROR_NONE, ret);
+	keynode_t* pKeyNode = _preference_keynode_new();
+	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
+
+	ret = _preference_keynode_set_keyname(pKeyNode, key);
+	if (ret != PREFERENCE_ERROR_NONE) {
+		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_IO_ERROR;
+	}
+
+	ret = _preference_get_key_path(pKeyNode, path);
+	if (ret != PREFERENCE_ERROR_NONE) {
+		_preference_keynode_free(pKeyNode);
+		return ret;
+	}
 
 	ret = access(path, F_OK);
-	if (ret == -1)
-	{
+	if (ret == -1) {
 		ERR("Error : key(%s) is not exist", key);
 		*exist = 0;
-	}
-	else
-	{
+	} else {
 		*exist = 1;
 	}
 
+	_preference_keynode_free(pKeyNode);
+
 	END_TIME_CHECK
 
 	return func_ret;
@@ -1293,31 +1392,34 @@ API int preference_set_changed_cb(const char *key, preference_changed_cb callbac
 {
 	START_TIME_CHECK
 
-	int ret = -1;
-	bool exist;
-
 	retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
 	retvm_if(callback == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: cb(%p)", callback);
 
-	ret = preference_is_existing(key, &exist);
-	if (ret != PREFERENCE_ERROR_NONE)
-	{
-		return ret;
-	}
+	int func_ret = PREFERENCE_ERROR_IO_ERROR;
 
-	if (!exist)
-	{
-		LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
-		return PREFERENCE_ERROR_NO_KEY;
+	keynode_t* pKeyNode = _preference_keynode_new();
+	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
+
+	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
+		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_IO_ERROR;
 	}
 
-	if (_preference_kdb_add_notify(key, callback, user_data)) {
-		if(errno != 0 && errno != ENOENT) {
+	if (_preference_kdb_add_notify(pKeyNode, callback, user_data)) {
+		if (errno == ENOENT) {
+			LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
+			_preference_keynode_free(pKeyNode);
+			return PREFERENCE_ERROR_NO_KEY;
+		} else if(errno != 0) {
 			ERR("preference_notify_key_changed : key(%s) add notify fail", key);
+			_preference_keynode_free(pKeyNode);
 			return PREFERENCE_ERROR_IO_ERROR;
 		}
 	}
 	INFO("%s noti is added", key);
+	_preference_keynode_free(pKeyNode);
 
 	END_TIME_CHECK
 
@@ -1328,30 +1430,33 @@ API int preference_unset_changed_cb(const char *key)
 {
 	START_TIME_CHECK
 
-	int ret = -1;
-	bool exist;
+	int func_ret = PREFERENCE_ERROR_IO_ERROR;
 
 	retvm_if(key == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is null");
 
-	ret = preference_is_existing(key, &exist);
-	if (ret != PREFERENCE_ERROR_NONE)
-	{
-		return ret;
-	}
+	keynode_t* pKeyNode = _preference_keynode_new();
+	retvm_if(pKeyNode == NULL, PREFERENCE_ERROR_OUT_OF_MEMORY, "key malloc fail");
 
-	if (!exist)
-	{
-		LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
-		return PREFERENCE_ERROR_NO_KEY;
+	func_ret = _preference_keynode_set_keyname(pKeyNode, key);
+	if (func_ret != PREFERENCE_ERROR_NONE) {
+		ERR("set key name error");
+		_preference_keynode_free(pKeyNode);
+		return PREFERENCE_ERROR_IO_ERROR;
 	}
 
-	if (_preference_kdb_del_notify(key)) {
-		if (errno != 0 && errno != ENOENT) {
+	if (_preference_kdb_del_notify(pKeyNode)) {
+		if (errno == ENOENT) {
+			LOGE("NO_KEY(0x%08x) : fail to find given key(%s)", PREFERENCE_ERROR_NO_KEY, key);
+			_preference_keynode_free(pKeyNode);
+			return PREFERENCE_ERROR_NO_KEY;
+		} else if (errno != 0) {
 			ERR("preference_unset_changed_cb() failed: key(%s) error(%d/%s)", key, errno, strerror(errno));
+			_preference_keynode_free(pKeyNode);
 			return PREFERENCE_ERROR_IO_ERROR;
 		}
 	}
 	INFO("%s noti removed", key);
+	_preference_keynode_free(pKeyNode);
 
 	END_TIME_CHECK
 
@@ -1371,26 +1476,22 @@ API int preference_foreach_item(preference_item_cb callback, void *user_data)
 	char *pref_dir_path = NULL;
 
 	pref_dir_path = _preference_get_pref_dir_path();
-	if (!pref_dir_path)
-	{
+	if (!pref_dir_path) {
 		LOGE("_preference_get_pref_dir_path() failed.");
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 
 	dir = opendir(pref_dir_path);
-	if (dir == NULL)
-	{
+	if (dir == NULL) {
 		LOGE("opendir() failed. path: %s, error: %d(%s)", pref_dir_path, errno, strerror(errno));
 		return PREFERENCE_ERROR_IO_ERROR;
 	}
 
-	while((dent = readdir(dir)))
-	{
+	while((dent = readdir(dir))) {
 		const char *entry = dent->d_name;
 		char keyname[PREFERENCE_KEY_PATH_LEN] = {0,};
 
-		if (entry[0] == '.')
-		{
+		if (entry[0] == '.') {
 			continue;
 		}
 
diff --git a/preference/preference_inoti.c b/preference/preference_inoti.c
index dbdea63..7cbffbd 100755
--- a/preference/preference_inoti.c
+++ b/preference/preference_inoti.c
@@ -160,20 +160,21 @@ static gboolean _preference_kdb_gio_cb(GIOChannel *src, GIOCondition cond, gpoin
 					}
 
 					if ( (t) && (t->wd == ie.wd) && (t->keyname) ) {
+
+						res = _preference_keynode_set_keyname(keynode, t->keyname);
+						if (res != PREFERENCE_ERROR_NONE) {
+							ERR("_preference_keynode_set_keyname() failed(%d)", res);
+							goto out_func;
+						}
+
 						if ((ie.mask & IN_DELETE_SELF))
 						{
-							res = _preference_kdb_del_notify(t->keyname);
+							res = _preference_kdb_del_notify(keynode);
 							if (res != PREFERENCE_ERROR_NONE)
 								ERR("_preference_kdb_del_notify() failed(%d)", res);
 						}
 						else
 						{
-							res = _preference_keynode_set_keyname(keynode, t->keyname);
-							if (res != PREFERENCE_ERROR_NONE) {
-								ERR("_preference_keynode_set_keyname() failed(%d)", res);
-								goto out_func;
-							}
-
 							res = _preference_get_key(keynode);
 							if (res != PREFERENCE_ERROR_NONE)
 								ERR("_preference_get_key() failed(%d)", res);
@@ -258,15 +259,16 @@ static int _preference_kdb_noti_init(void)
 	return PREFERENCE_ERROR_NONE;
 }
 
-int _preference_kdb_add_notify(const char *keyname, preference_changed_cb cb, void *data)
+int _preference_kdb_add_notify(keynode_t *keynode, preference_changed_cb cb, void *data)
 {
-	char path[PREFERENCE_KEY_PATH_LEN];
+	char path[PATH_MAX];
 	int wd;
 	struct noti_node t, *n, *node;
 	char err_buf[ERR_LEN] = { 0, };
 	int ret = 0;
 	GList *list = NULL;
 	int func_ret = PREFERENCE_ERROR_NONE;
+	char *keyname = keynode->keyname;
 
 	retvm_if((keyname == NULL || cb == NULL), PREFERENCE_ERROR_INVALID_PARAMETER,
 			"_preference_kdb_add_notify : Invalid argument - keyname(%s) cb(%p)",
@@ -276,8 +278,11 @@ int _preference_kdb_add_notify(const char *keyname, preference_changed_cb cb, vo
 		if (_preference_kdb_noti_init())
 			return PREFERENCE_ERROR_IO_ERROR;
 
-	ret = _preference_get_key_path((char*)keyname, path);
-	retvm_if(ret != PREFERENCE_ERROR_NONE, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is not valid");
+	ret = _preference_get_key_path(keynode, path);
+	if (ret != PREFERENCE_ERROR_NONE) {
+		ERR("Invalid argument: key is not valid");
+		return PREFERENCE_ERROR_INVALID_PARAMETER;
+	}
 
 	if (0 != access(path, F_OK)) {
 		if (errno == ENOENT) {
@@ -318,8 +323,7 @@ int _preference_kdb_add_notify(const char *keyname, preference_changed_cb cb, vo
 	}
 
 	n->keyname = strndup(keyname, PREFERENCE_KEY_PATH_LEN);
-	if (n->keyname == NULL)
-	{
+	if (n->keyname == NULL) {
 		ERR("The memory is insufficient, errno: %d (%s)", errno, strerror(errno));
 		free(n);
 		goto out_func;
@@ -341,24 +345,36 @@ out_func:
 	return func_ret;
 }
 
-int _preference_kdb_del_notify(const char *keyname)
+int _preference_kdb_del_notify(keynode_t *keynode)
 {
 	int wd = 0;
 	int r = 0;
 	struct noti_node *n = NULL;
 	struct noti_node t;
-	char path[PREFERENCE_KEY_PATH_LEN] = { 0, };
+	char path[PATH_MAX] = { 0, };
 	char err_buf[ERR_LEN] = { 0, };
 	int del = 0;
 	int ret = 0;
+	char *keyname = keynode->keyname;
 	int func_ret = PREFERENCE_ERROR_NONE;
 	GList *noti_list;
 
 	retvm_if(keyname == NULL, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: keyname(%s)", keyname);
-	retvm_if(_kdb_inoti_fd == 0, PREFERENCE_ERROR_NONE, "Invalid operation: not exist anything for inotify");
 
-	ret = _preference_get_key_path((char*)keyname, path);
-	retvm_if(ret != PREFERENCE_ERROR_NONE, PREFERENCE_ERROR_INVALID_PARAMETER, "Invalid argument: key is not valid");
+	ret = _preference_get_key_path(keynode, path);
+	if (ret != PREFERENCE_ERROR_NONE) {
+		ERR("Invalid argument: key is not valid");
+		return PREFERENCE_ERROR_INVALID_PARAMETER;
+	}
+
+	if (0 != access(path, F_OK)) {
+		if (errno == ENOENT) {
+			ERR("_preference_kdb_del_notify : Key(%s) does not exist", keyname);
+			return PREFERENCE_ERROR_IO_ERROR;
+		}
+	}
+
+	retvm_if(_kdb_inoti_fd == 0, PREFERENCE_ERROR_NONE, "Invalid operation: not exist anything for inotify");
 
 	/* get wd */
 	wd = inotify_add_watch(_kdb_inoti_fd, path, INOTY_EVENT_MASK);