#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>
+
+#ifdef PREFERENCE_TIMECHECK
+#include <sys/time.h>
+#endif
+
#ifndef API
#define API __attribute__ ((visibility("default")))
#endif
static int g_preference_errno;
static char *g_pref_dir_path = NULL;
-
enum preference_op_t {
PREFERENCE_OP_GET = 0,
PREFERENCE_OP_SET = 1
{
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);
}
}
-int _preference_get_key_name(const char *keyfile, char *keyname)
+int _preference_get_key_name(const char *path, char **keyname)
{
- char convert_key[PREFERENCE_KEY_PATH_LEN] = {0,};
- char *chrptr = NULL;
+ int read_size = 0;
+ size_t keyname_len = 0;
+ char *convert_key = NULL;
+ FILE *fp = NULL;
+
+ if( (fp = fopen(path, "r")) == NULL ) {
+ return PREFERENCE_ERROR_FILE_OPEN;
+ }
- strncpy(convert_key, keyfile, strlen(keyfile));
+ read_size = fread((void *)&keyname_len, sizeof(int), 1, fp);
+ if (read_size <= 0) {
+ fclose(fp);
+ return PREFERENCE_ERROR_FILE_FREAD;
+ }
- 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);
- }
+ convert_key = (char *)calloc(1, keyname_len+1);
+ if (convert_key == NULL) {
+ LOGE("memory alloc failed");
+ fclose(fp);
+ return PREFERENCE_ERROR_OUT_OF_MEMORY;
}
- snprintf(keyname, PREFERENCE_KEY_PATH_LEN, "%s", (const char*)convert_key);
+
+ read_size = fread((void *)convert_key, keyname_len, 1, fp);
+ if (read_size <= 0) {
+ free(convert_key);
+ fclose(fp);
+ return PREFERENCE_ERROR_FILE_FREAD;
+ }
+
+ *keyname = convert_key;
+
+ fclose(fp);
return PREFERENCE_ERROR_NONE;
}
-
-int _preference_get_key_path(const char *keyname, char *path)
+int _preference_get_key_path(keynode_t *keynode, char *path)
{
const char *key = NULL;
+ char *pref_dir_path = NULL;
+ gchar *convert_key;
+ char *keyname = keynode->keyname;
if(!keyname) {
- ERR("keyname is null");
+ LOGE("keyname is null");
return PREFERENCE_ERROR_WRONG_PREFIX;
}
- char convert_key[PREFERENCE_KEY_PATH_LEN] = {0,};
- char *chrptr = NULL;
- char *pref_dir_path = NULL;
-
- strncpy(convert_key, 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.");
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)'/');
- }
- key = (const char*)convert_key;
+ convert_key = g_compute_checksum_for_string(G_CHECKSUM_SHA1,
+ keyname,
+ strlen(keyname));
+ if (convert_key == NULL) {
+ LOGE("fail to convert");
+ return PREFERENCE_ERROR_IO_ERROR;
}
- 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;
}
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;
}
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;
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;
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);
}
break;
}
+ case EACCES :
+ {
+ _preference_log_subject_label();
+ break;
+ }
case EAGAIN :
case EMFILE :
case ENFILE :
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;
char err_buf[100] = { 0, };
int is_write_error = 0;
int retry_cnt = 0;
+ size_t keyname_len = 0;
retry_open :
errno = 0;
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 ) {
func_ret = PREFERENCE_ERROR_NONE;
ret = _preference_set_write_lock(fileno(fp));
- if(ret == -1) {
+ if (ret == -1) {
func_ret = PREFERENCE_ERROR_FILE_LOCK;
err_no = errno;
ERR("file(%s) lock owner(%d)",
goto out_return;
}
+ /* write keyname and size */
+ keyname_len = strlen(keynode->keyname);
+
+ ret = fwrite((void *)&keyname_len, sizeof(int), 1, fp);
+ if (ret <= 0) {
+ if (!errno) {
+ LOGW("number of written items is 0. try again");
+ errno = EAGAIN;
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_WRITE;
+ goto out_unlock;
+ }
+
+ ret = fwrite((void *)keynode->keyname, keyname_len, 1, fp);
+ if (ret <= 0) {
+ if (!errno) {
+ LOGW("number of written items is 0. try again");
+ errno = EAGAIN;
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_WRITE;
+ goto out_unlock;
+ }
+
/* write key type */
ret = fwrite((void *)&(keynode->type), sizeof(int), 1, fp);
- if(ret <= 0)
- {
- if(!errno) {
+ if (ret <= 0) {
+ if (!errno) {
LOGW("number of written items is 0. try again");
errno = EAGAIN;
}
}
/* write key value */
- switch(keynode->type)
- {
- case PREFERENCE_TYPE_INT:
- ret = fwrite((void *)&(keynode->value.i), sizeof(int), 1, fp);
- if(ret <= 0) is_write_error = 1;
- break;
- case PREFERENCE_TYPE_DOUBLE:
- ret = fwrite((void *)&(keynode->value.d), sizeof(double), 1, fp);
- if(ret <= 0) is_write_error = 1;
- break;
- case PREFERENCE_TYPE_BOOLEAN:
- ret = fwrite((void *)&(keynode->value.b), sizeof(int), 1, fp);
- if(ret <= 0) is_write_error = 1;
- break;
- case PREFERENCE_TYPE_STRING:
- ret = fprintf(fp,"%s",keynode->value.s);
- if(ret < strlen(keynode->value.s)) is_write_error = 1;
- if (ftruncate(fileno(fp), ret) == -1) {
- is_write_error = 1;
- }
- break;
- default :
- func_ret = PREFERENCE_ERROR_WRONG_TYPE;
- goto out_unlock;
+ switch (keynode->type) {
+ case PREFERENCE_TYPE_INT:
+ ret = fwrite((void *)&(keynode->value.i), sizeof(int), 1, fp);
+ if (ret <= 0) is_write_error = 1;
+ break;
+ case PREFERENCE_TYPE_DOUBLE:
+ ret = fwrite((void *)&(keynode->value.d), sizeof(double), 1, fp);
+ if (ret <= 0) is_write_error = 1;
+ break;
+ case PREFERENCE_TYPE_BOOLEAN:
+ ret = fwrite((void *)&(keynode->value.b), sizeof(int), 1, fp);
+ if (ret <= 0) is_write_error = 1;
+ break;
+ case PREFERENCE_TYPE_STRING:
+ ret = fprintf(fp,"%s",keynode->value.s);
+ if (ret < strlen(keynode->value.s)) is_write_error = 1;
+ if (ftruncate(fileno(fp), ret) == -1)
+ is_write_error = 1;
+ break;
+ default :
+ func_ret = PREFERENCE_ERROR_WRONG_TYPE;
+ goto out_unlock;
}
- if(is_write_error)
- {
- if(!errno) {
+
+ if (is_write_error) {
+ if (!errno) {
LOGW("number of written items is 0. try again");
errno = EAGAIN;
}
out_unlock :
ret = _preference_set_unlock(fileno(fp));
- if(ret == -1) {
+ if (ret == -1) {
func_ret = PREFERENCE_ERROR_FILE_LOCK;
err_no = errno;
goto out_return;
}
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_SET))
- {
- if (retry_cnt < PREFERENCE_ERROR_RETRY_CNT)
- {
+ if (_preference_check_retry_err(keynode, func_ret, err_no, PREFERENCE_OP_SET)) {
+ if (retry_cnt < PREFERENCE_ERROR_RETRY_CNT) {
WARN("_preference_set_key_filesys(%d-%s) step(%d) failed(%d / %s) retry(%d)", keynode->type, keynode->keyname, func_ret, err_no, err_buf, retry_cnt);
retry_cnt++;
usleep((retry_cnt)*PREFERENCE_ERROR_RETRY_SLEEP_UTIME);
goto retry;
else
goto retry_open;
- }
- else
- {
+ } else {
ERR("_preference_set_key_filesys(%d-%s) step(%d) faild(%d / %s) over the retry count.",
keynode->type, keynode->keyname, func_ret, err_no, err_buf);
}
- }
- else
- {
+ } else {
ERR("_preference_set_key_filesys(%d-%s) step(%d) failed(%d / %s)\n", keynode->type, keynode->keyname, func_ret, err_no, err_buf);
}
} else {
}
}
- if (fp)
- {
- if(func_ret == PREFERENCE_ERROR_NONE)
- {
+ if (fp) {
+ if (func_ret == PREFERENCE_ERROR_NONE) {
ret = fdatasync(fileno(fp));
- if(ret == -1) {
+ if (ret == -1) {
err_no = errno;
func_ret = PREFERENCE_ERROR_FILE_SYNC;
}
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;
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);
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);
}
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);
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);
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);
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, };
FILE *fp = NULL;
int retry_cnt = 0;
int read_size = 0;
+ size_t keyname_len = 0;
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 ) {
func_ret = PREFERENCE_ERROR_NONE;
ret = _preference_set_read_lock(fileno(fp));
- if(ret == -1) {
+ if (ret == -1) {
func_ret = PREFERENCE_ERROR_FILE_LOCK;
err_no = errno;
goto out_return;
}
+ read_size = fread((void *)&keyname_len, sizeof(int), 1, fp);
+ if ((read_size <= 0) || (read_size > sizeof(int))) {
+ if(!ferror(fp)) {
+ errno = ENODATA;
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_FREAD;
+ goto out_unlock;
+ }
+
+ ret = fseek(fp, keyname_len, SEEK_CUR);
+ if (ret) {
+ if(!ferror(fp)) {
+ errno = ENODATA;
+ }
+ err_no = errno;
+ func_ret = PREFERENCE_ERROR_FILE_FREAD;
+ goto out_unlock;
+ }
- /* read data type */
- read_size = fread((void*)&type, sizeof(int), 1, fp);
- if((read_size <= 0) || (read_size > sizeof(int))) {
+ read_size = fread((void *)&type, sizeof(int), 1, fp);
+ if (read_size <= 0) {
if(!ferror(fp)) {
- LOGW("number of read items for type is 0 with false ferror. err : %d", errno);
errno = ENODATA;
}
err_no = errno;
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)) {
+ if ((read_size <= 0) || (read_size > sizeof(int))) {
+ if (!ferror(fp)) {
LOGW("number of read items for value is wrong. err : %d", errno);
}
err_no = errno;
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)) {
+ if ((read_size <= 0) || (read_size > sizeof(double))) {
+ if (!ferror(fp)) {
LOGW("number of read items for value is wrong. err : %d", errno);
}
err_no = errno;
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)) {
+ if ((read_size <= 0) || (read_size > sizeof(int))) {
+ if (!ferror(fp)) {
LOGW("number of read items for value is wrong. err : %d", errno);
}
err_no = errno;
while(fgets(file_buf, sizeof(file_buf), fp))
{
- if(value) {
+ if (value) {
value_size = value_size + strlen(file_buf);
value = (char *) realloc(value, value_size);
- if(value == NULL) {
+ if (value == NULL) {
func_ret = PREFERENCE_ERROR_OUT_OF_MEMORY;
break;
}
} else {
value_size = strlen(file_buf) + 1;
value = (char *)malloc(value_size);
- if(value == NULL) {
+ if (value == NULL) {
func_ret = PREFERENCE_ERROR_OUT_OF_MEMORY;
break;
}
}
}
- if(ferror(fp)) {
+ if (ferror(fp)) {
err_no = errno;
func_ret = PREFERENCE_ERROR_FILE_FGETS;
} else {
- if(value) {
+ if (value) {
_preference_keynode_set_value_string(keynode, value);
} else {
_preference_keynode_set_value_string(keynode, "");
}
}
- if(value)
+ if (value)
free(value);
break;
out_unlock :
ret = _preference_set_unlock(fileno(fp));
- if(ret == -1) {
+ if (ret == -1) {
func_ret = PREFERENCE_ERROR_FILE_LOCK;
err_no = errno;
goto out_return;
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);
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)
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
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 {
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);
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 {
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);
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 {
/*
* 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)
{
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);
{
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");
- retvm_if(access(path, F_OK) == -1, PREFERENCE_ERROR_NO_KEY, "Error : key(%s) is not exist", key);
+ 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;
+ }
+
+ 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);
}
} while(err_retry--);
- END_TIME_CHECK
+ END_TIME_CHECK;
+
+ _preference_keynode_free(pKeyNode);
return func_ret;
}
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 *keyname = NULL;
+ char path[PATH_MAX] = {0,};
- if (entry[0] == '.')
- {
+ if (entry[0] == '.') {
continue;
}
- ret = _preference_get_key_name(entry, keyname);
- if (ret != PREFERENCE_ERROR_NONE)
- {
+ snprintf(path, PATH_MAX-1, "%s%s", pref_dir_path, entry);
+
+ ret = _preference_get_key_name(path, &keyname);
+ 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);
+ free(keyname);
return PREFERENCE_ERROR_IO_ERROR;
}
- ret = _preference_get_key_path(keyname, path);
- if (ret != PREFERENCE_ERROR_NONE)
- {
- ERR("_preference_get_key_path() failed(%d)", ret);
- closedir(dir);
- return ret;
- }
-
- // delete
do {
ret = remove(path);
- if(ret == -1) {
+ if (ret == -1) {
ERR("preference_remove_all error: %d(%s)", errno, strerror(errno));
func_ret = PREFERENCE_ERROR_IO_ERROR;
} else {
break;
}
} while(err_retry--);
+
+ free(keyname);
}
+ _preference_keynode_free(pKeyNode);
closedir(dir);
END_TIME_CHECK
{
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;
{
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
{
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
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,};
+ char *keyname = NULL;
+ char path[PATH_MAX] = {0,};
- if (entry[0] == '.')
- {
+ if (entry[0] == '.') {
continue;
}
- ret = _preference_get_key_name(entry, keyname);
+ snprintf(path, PATH_MAX-1, "%s%s", pref_dir_path, entry);
+
+ ret = _preference_get_key_name(path, &keyname);
retv_if(ret != PREFERENCE_ERROR_NONE, ret);
callback(keyname, user_data);
+ free(keyname);
}
closedir(dir);
projects / platform / core / api / application.git / blobdiff