#define EMAIL_ERROR_TASK_BINDER_NOT_FOUND -1023 /**< No matched task binder was found */
#define EMAIL_ERROR_TASK_NOT_FOUND -1168 /**< No matched task was found */
#define EMAIL_ERROR_HANDLE_NOT_FOUND -1169 /**< No matched handle was found */
+#define EMAIL_ERROR_KEY_NOT_FOUND -1170 /**< No matched key was found */
#define EMAIL_ERROR_ALARM_DATA_NOT_FOUND -1933 /**< No matched alarm data was found */
/* Error codes for specification for maximum data */
#define EMAIL_ERROR_GCONF_FAILURE -1058 /**< The error occurred on accessing Gconf */
#define EMAIL_ERROR_FILE -1059 /**< File related error */
#define EMAIL_ERROR_SERVER_STORAGE_FULL -2101 /**< There is no more storage in server */
+#define EMAIL_ERROR_KEY_MANAGER_FAILURE -2102 /**< The error occurred on key-manager*/
/* Error codes for network */
#define EMAIL_ERROR_SOCKET_FAILURE -1031 /**< Socket operation failed */
/* Feature definitions */
/* #define __FEATURE_USING_ACCOUNT_SVC_FOR_ACCOUNT_MANAGEMENT__ */
#define __FEATURE_USING_ACCOUNT_SVC_FOR_SYNC_STATUS__
-// #define __FEATURE_BACKUP_ACCOUNT__
+#define __FEATURE_BACKUP_ACCOUNT__
#define __FEATURE_MOVE_TO_OUTBOX_FIRST__
#define __FEATURE_PARTIAL_BODY_FOR_POP3__
/* #define __FEATURE_KEEP_CONNECTION__ */
SET(PKG_MODULES glib-2.0 dlog dbus-1 gthread-2.0 key-manager tpkp-curl
uw-imap-toolkit vconf vconf-internal-keys contacts-service2
openssl accounts-svc alarm-service notification libcurl libxml-2.0
- cert-svc-vcore badge capi-appfw-application icu-i18n gmime-2.6 storage dpm)
+ cert-svc-vcore badge capi-appfw-application icu-i18n gmime-2.6 storage dpm cryptsvc)
pkg_check_modules(core_pkgs REQUIRED ${PKG_MODULES})
#include <curl/curl.h>
#include <sys/shm.h>
#include <tpkp_curl.h>
+#include <ckmc/ckmc-manager.h>
+
#include "email-convert.h"
#include "email-types.h"
#include "email-core-signal.h"
#include "email-core-imap-mailbox.h"
#include "email-core-container.h"
+#include "email-core-key-manager.h"
#include "imap4r1.h"
#include "account.h"
#include "account-types.h"
+#define EMAIL_SERVICE_BNR_ACCOUNT_KEY "email_service_backup_restore_account_key"
+
char *g_default_mbox_alias[MAILBOX_COUNT] = {
EMAIL_INBOX_DISPLAY_NAME,
EMAIL_DRAFTBOX_DISPLAY_NAME,
}
}
+
error_code = account_create(&account_handle);
if (error_code != ACCOUNT_ERROR_NONE) {
EM_DEBUG_EXCEPTION("account_create failed [%d]", error_code);
INTERNAL_FUNC int emcore_backup_accounts(char *multi_user_name, const char *file_path, int *error_code)
{
- EM_DEBUG_FUNC_BEGIN_SEC("file_path [%s], error_code [%p]", file_path, error_code);
+ EM_DEBUG_LOG("file_path [%s], error_code [%p]", file_path, error_code);
int local_error_code = EMAIL_ERROR_NONE, local_error_code_2 = EMAIL_ERROR_NONE, ret_code = false;
int select_num, i, target_buff_length = 0;
int normal_email_account_count = 0;
char *target_buffer = NULL;
+ unsigned char *output_data = NULL;
emstorage_account_tbl_t *account_list = NULL;
- int fd = 0;
+ int fd = -1;
if (!file_path) {
local_error_code = EMAIL_ERROR_INVALID_PARAM;
EM_DEBUG_LOG("target_buff_length [%d]", target_buff_length);
- ssm_delete_file(file_path, SSM_FLAG_SECRET_OPERATION, NULL);
-
- if (ssm_write_buffer(target_buffer, target_buff_length, file_path, SSM_FLAG_SECRET_OPERATION, NULL) < 0) {
- EM_DEBUG_EXCEPTION("ssm_write_buffer failed [%d]", local_error_code);
- local_error_code = EMAIL_ERROR_SYSTEM_FAILURE;
- goto FINISH_OFF;
+ local_error_code = em_open(file_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR, &fd);
+ if (local_error_code != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("em_open failed - %d [%s] : ", local_error_code, file_path);
+ goto FINISH_OFF;
}
+
+
+ int tmp = emcore_check_key_in_key_manager(EMAIL_SERVICE_BNR_ACCOUNT_KEY);
+
+ if (tmp == EMAIL_ERROR_KEY_NOT_FOUND){
+ EM_DEBUG_LOG("Key not exist");
+
+ int ret = 0;
+
+ ret = emcore_save_key_in_key_manager(EMAIL_SERVICE_BNR_ACCOUNT_KEY);
+
+ if(ret != EMAIL_ERROR_NONE){
+ EM_DEBUG_EXCEPTION("save key failed %d", ret);
+ goto FINISH_OFF;
+ }
+
+ } else if (tmp == EMAIL_ERROR_INVALID_PARAM) {
+
+ EM_DEBUG_EXCEPTION("Invalid parameter");
+ goto FINISH_OFF;
+
+ }
+ int output_length = 0;
+ emcore_encryption_data_in_key_manager(EMAIL_SERVICE_BNR_ACCOUNT_KEY, target_buffer, target_buff_length, &output_data, &output_length);
+
+ EM_DEBUG_LOG("output length %d", output_length);
+ int write_length = write(fd, (char *)output_data, output_length);
+ EM_DEBUG_LOG("write length : %d", write_length);
+
}
ret_code = true;
EM_SAFE_CLOSE(fd);
EM_SAFE_FREE(target_buffer);
+ EM_SAFE_FREE(output_data);
if (account_list)
emstorage_free_account(&account_list, select_num, &local_error_code_2);
INTERNAL_FUNC int emcore_restore_accounts(char *multi_user_name, const char *file_path)
{
EM_DEBUG_FUNC_BEGIN_SEC("file_path [%s]", file_path);
- int err = EMAIL_ERROR_NONE, buffer_length = 0, read_length = 0;
+ int err = EMAIL_ERROR_NONE;
int account_count = 0, i = 0, account_stream_length = 0;
char *temp_buffer = NULL, *account_stream = NULL, *buffer_ptr = NULL;
email_account_t temp_account = {0};
email_account_t *account_list = NULL;
- char errno_buf[ERRNO_BUF_SIZE] = {0};
char *encrypt_buffer = NULL;
- ssm_file_info_t sfi;
if (!emcore_notify_storage_event(NOTI_ACCOUNT_RESTORE_START, 0, 0, NULL, 0))
EM_DEBUG_EXCEPTION("emcore_notify_storage_event[NOTI_ACCOUNT_RESTORE_START] failed");
}
}
- if (ssm_getinfo(file_path, &sfi, SSM_FLAG_SECRET_OPERATION, NULL) < 0) {
- EM_DEBUG_EXCEPTION("ssm_getinfo() failed.");
- err = EMAIL_ERROR_SYSTEM_FAILURE;
- goto FINISH_OFF;
- }
-
- buffer_length = sfi.originSize;
- EM_DEBUG_LOG("account buffer_length[%d]", buffer_length);
- if ((encrypt_buffer = (char *)em_malloc(buffer_length + 1)) == NULL) {
- EM_DEBUG_EXCEPTION("em_mallocfailed...");
- err = EMAIL_ERROR_OUT_OF_MEMORY;
- goto FINISH_OFF;
- }
-
- if (ssm_read(file_path, temp_buffer, buffer_length, (size_t *)&read_length, SSM_FLAG_SECRET_OPERATION, NULL) < 0) {
- EM_DEBUG_EXCEPTION("ssm_read() failed.");
- err = EMAIL_ERROR_SYSTEM_FAILURE;
- goto FINISH_OFF;
- }
+ int output_length = 0;
+ char *output_data = NULL;
- EM_DEBUG_LOG("read_length[%d]", read_length);
+ emcore_decryption_data_from_file_in_key_manager(EMAIL_SERVICE_BNR_ACCOUNT_KEY, file_path, &output_data, &output_length);
- if (buffer_length == read_length) {
- memcpy((void *)&account_count, temp_buffer, sizeof(int));
- buffer_ptr = temp_buffer + sizeof(int);
+ if (output_length > 0) {
+ memcpy((void *)&account_count, output_data, sizeof(int));
+ buffer_ptr = output_data + sizeof(int);
EM_DEBUG_LOG("account_count[%d]", account_count);
EM_SAFE_FREE(account_stream);
EM_SAFE_FREE(temp_buffer);
EM_SAFE_FREE(encrypt_buffer);
+ EM_SAFE_FREE(output_data);
EM_DEBUG_FUNC_END("err [%d]", err);
return err;
*/
#include <ckmc/ckmc-manager.h>
+#include <ckmc/ckmc-type.h>
+#include <SecCryptoSvc.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
#include "email-core-utils.h"
#include "email-debug-log.h"
#include "email-utilities.h"
+
+#define EMAIL_SERVICE_CS_DERIVE_PASS "email_service_cs_derive_pass"
+
/* Adding '/' method for system daemon */
/*
static char *add_shared_owner_prefix(const char *name)
return ckm_alias;
}
*/
+static char *__get_key_manager_alias(const char* name)
+{
+ int ret = 0;
+ char *ckmc_alias = NULL;
+
+ ret = ckmc_alias_new("/User", name, &ckmc_alias);
+ if (ret != CKMC_ERROR_NONE) {
+ EM_DEBUG_LOG("ckmc_alias_new failed");
+ return NULL;
+
+ }
+ EM_DEBUG_LOG("alias : [%s]", ckmc_alias);
+ return ckmc_alias;
+
+}
/* Add new data */
INTERNAL_FUNC int emcore_add_password_in_key_manager(char *data_name, char *stored_data)
{
return err;
}
-// alias = add_shared_owner_prefix(data_name);
- alias = g_strdup(data_name);
+ alias = __get_key_manager_alias(data_name);
EM_DEBUG_LOG("alias : [%s]", alias);
email_policy.password = NULL;
return err;
}
-// alias = add_shared_owner_prefix(data_name);
- alias = g_strdup(data_name);
+ alias = __get_key_manager_alias(data_name);
EM_DEBUG_LOG("alias : [%s]", alias);
ckmc_ret = ckmc_get_data(alias, NULL, &email_data);
return err;
}
-// alias = add_shared_owner_prefix(data_name);
- alias = g_strdup(data_name);
+ alias = __get_key_manager_alias(data_name);
EM_DEBUG_LOG("alias : [%s]", alias);
ckmc_ret = ckmc_remove_alias(alias);
if (ckmc_ret != CKMC_ERROR_NONE) {
EM_DEBUG_EXCEPTION("ckmc_remove_alias failed : [%d]", ckmc_ret);
+
err = EMAIL_ERROR_SECURED_STORAGE_FAILURE;
goto FINISH_OFF;
}
EM_DEBUG_FUNC_END();
return err;
}
+
+/* check key in key manager */
+INTERNAL_FUNC int emcore_check_key_in_key_manager(const char *data_name)
+{
+ EM_DEBUG_FUNC_BEGIN();
+ int err = EMAIL_ERROR_NONE;
+ int ckmc_ret = CKMC_ERROR_NONE;
+ char *alias = NULL;
+ ckmc_key_s *email_key = NULL;
+
+ if (data_name == NULL) {
+ EM_DEBUG_EXCEPTION("Invalid parameter");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ return err;
+ }
+
+ alias = __get_key_manager_alias(data_name);
+
+ if (alias == NULL) {
+ EM_DEBUG_EXCEPTION("Invalid parameter");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ return err;
+ }
+
+
+ ckmc_ret = ckmc_get_key(alias, NULL, &email_key);
+ if (ckmc_ret == CKMC_ERROR_DB_ALIAS_UNKNOWN) {
+ EM_DEBUG_EXCEPTION("email error key not found");
+ err = EMAIL_ERROR_KEY_NOT_FOUND;
+ goto FINISH_OFF;
+ }
+
+
+FINISH_OFF:
+ if (email_key != NULL) {
+ ckmc_key_free(email_key);
+ }
+
+
+ EM_SAFE_FREE(alias);
+
+ EM_DEBUG_FUNC_END();
+ return err;
+}
+
+
+
+/* save key in key manager */
+INTERNAL_FUNC int emcore_save_key_in_key_manager(const char *data_name)
+{
+ EM_DEBUG_FUNC_BEGIN();
+ int err = EMAIL_ERROR_NONE;
+ int ckmc_ret = CKMC_ERROR_NONE;
+ ckmc_key_s email_key;
+ ckmc_policy_s email_policy;
+
+ const char *pass = EMAIL_SERVICE_CS_DERIVE_PASS;
+ unsigned char *pass_key = NULL;
+ char *alias = NULL;
+
+ if (data_name == NULL) {
+ EM_DEBUG_EXCEPTION("Invalid parameter");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ return err;
+ }
+
+
+ int cs_ret = cs_derive_key_with_pass(pass, strlen(pass), 32, &pass_key);
+
+ if (cs_ret != CS_ERROR_NONE) {
+ EM_DEBUG_LOG("creat key failed");
+ err = EMAIL_ERROR_KEY_MANAGER_FAILURE;
+ goto FINISH_OFF;
+ }
+
+ email_key.raw_key = (unsigned char *)pass_key;
+ email_key.key_size = 32;
+ email_key.key_type = CKMC_KEY_AES;
+ email_key.password = NULL;
+
+ email_policy.password = NULL;
+ email_policy.extractable = false;
+
+ alias = __get_key_manager_alias(data_name);
+
+ ckmc_ret = ckmc_save_key(alias, email_key, email_policy);
+
+ if (ckmc_ret != CKMC_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("email error key not save : %s", get_error_message(ckmc_ret));
+ err = EMAIL_ERROR_KEY_MANAGER_FAILURE;
+ goto FINISH_OFF;
+ }
+
+
+FINISH_OFF:
+
+
+ EM_SAFE_FREE(alias);
+ EM_DEBUG_FUNC_END();
+ return err;
+}
+
+
+
+/* encrypte data */
+INTERNAL_FUNC int emcore_encryption_data_in_key_manager(const char *data_name, char *input_data, int input_length, unsigned char **output_data, int *output_length)
+{
+ EM_DEBUG_FUNC_BEGIN();
+ int err = EMAIL_ERROR_NONE;
+ int ckmc_ret = CKMC_ERROR_NONE;
+
+ ckmc_raw_buffer_s plaintext;
+ ckmc_raw_buffer_s *encrypted = NULL;
+ ckmc_param_list_h params = NULL;
+
+ unsigned char iv[16] = {0, };
+ ckmc_raw_buffer_s iv_buffer;
+ iv_buffer.data = iv;
+ iv_buffer.size = sizeof(iv);
+
+
+ plaintext.data = (unsigned char *)input_data;
+ plaintext.size = input_length;
+
+ if (data_name == NULL) {
+ EM_DEBUG_EXCEPTION("Invalid parameter");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ return err;
+ }
+
+
+ ckmc_ret = ckmc_generate_new_params(CKMC_ALGO_AES_CBC, ¶ms);
+ if (ckmc_ret != CKMC_ERROR_NONE) {
+
+ EM_DEBUG_LOG("ckmc_generate_new_params failed");
+ err = EMAIL_ERROR_KEY_MANAGER_FAILURE;
+ return err;
+
+ }
+
+
+ ckmc_ret = ckmc_param_list_set_buffer(params, CKMC_PARAM_ED_IV, &iv_buffer);
+ if (ckmc_ret != CKMC_ERROR_NONE) {
+
+ EM_DEBUG_LOG("ckmc_param_list_set_buffer failed");
+ err = EMAIL_ERROR_KEY_MANAGER_FAILURE;
+ return err;
+
+ }
+
+
+ char *alias = __get_key_manager_alias(data_name);
+ ckmc_ret = ckmc_encrypt_data(params, alias, NULL, plaintext, &encrypted);
+ if (ckmc_ret != CKMC_ERROR_NONE) {
+
+ EM_DEBUG_LOG("ckmc_encrypt_data failed");
+ err = EMAIL_ERROR_KEY_MANAGER_FAILURE;
+ goto FINISH_OFF;
+
+ }
+
+ *output_data = encrypted->data;
+ *output_length = encrypted->size;
+
+ if (encrypted->data != NULL)
+ encrypted->data = NULL;
+
+
+
+
+
+FINISH_OFF:
+
+ if (encrypted != NULL)
+ ckmc_buffer_free(encrypted);
+
+ if (params != NULL)
+ ckmc_param_list_free(params);
+
+
+
+ EM_SAFE_FREE(alias);
+ EM_DEBUG_FUNC_END();
+ return err;
+}
+
+
+
+/* decrypte data from file */
+INTERNAL_FUNC int emcore_decryption_data_from_file_in_key_manager(const char *data_name, const char *file_path, char **output_data, int *output_length)
+{
+ EM_DEBUG_FUNC_BEGIN();
+ int err = EMAIL_ERROR_NONE;
+ int ckmc_ret = CKMC_ERROR_NONE;
+ int buffer_length = 0;
+ ckmc_raw_buffer_s *encrypted = NULL;
+ ckmc_raw_buffer_s *decrypted = NULL;
+ ckmc_param_list_h params = NULL;
+
+ char *alias = NULL;
+ char errno_buf[ERRNO_BUF_SIZE] = {0};
+ unsigned char iv[16] = {0, };
+ ckmc_raw_buffer_s iv_buffer;
+ iv_buffer.data = iv;
+ iv_buffer.size = sizeof(iv);
+
+ if (data_name == NULL && file_path == NULL) {
+ EM_DEBUG_EXCEPTION("Invalid parameter");
+ err = EMAIL_ERROR_INVALID_PARAM;
+ return err;
+ }
+
+
+ int fd = 0;
+ struct stat st_buf;
+
+ if (stat(file_path, &st_buf) < 0) {
+ EM_DEBUG_EXCEPTION("stat(\"%s\") failed...", file_path);
+ err = EMAIL_ERROR_SYSTEM_FAILURE;
+ goto FINISH_OFF;
+ }
+
+ err = em_open(file_path, O_RDONLY, 0, &fd);
+ if (err != EMAIL_ERROR_NONE) {
+ EM_DEBUG_EXCEPTION("em_open failed : [%d] [%s]", err, file_path);
+ goto FINISH_OFF;
+ }
+
+
+ buffer_length = st_buf.st_size;
+ EM_DEBUG_LOG("account buffer_length[%d]", buffer_length);
+
+
+ encrypted = (ckmc_raw_buffer_s*)malloc(sizeof(ckmc_raw_buffer_s));
+
+ if ((encrypted->data = (unsigned char *)em_malloc(buffer_length + 1)) == NULL) {
+ EM_DEBUG_EXCEPTION("em_malloc failed...");
+ err = EMAIL_ERROR_OUT_OF_MEMORY;
+ goto FINISH_OFF;
+
+ }
+
+
+ if (read(fd, encrypted->data, buffer_length) < 0) {
+ EM_DEBUG_EXCEPTION("read failed : [%s]", EM_STRERROR(errno_buf));
+ err = EMAIL_ERROR_SYSTEM_FAILURE;
+ goto FINISH_OFF;
+ }
+ encrypted->size = buffer_length;
+
+
+ ckmc_ret = ckmc_generate_new_params(CKMC_ALGO_AES_CBC, ¶ms);
+ if (ckmc_ret != CKMC_ERROR_NONE) {
+
+ EM_DEBUG_LOG("ckmc_generate_new_params failed");
+ err = EMAIL_ERROR_KEY_MANAGER_FAILURE;
+ goto FINISH_OFF;
+
+ }
+
+
+ ckmc_ret = ckmc_param_list_set_buffer(params, CKMC_PARAM_ED_IV, &iv_buffer);
+ if (ckmc_ret != CKMC_ERROR_NONE) {
+
+ EM_DEBUG_LOG("ckmc_param_list_set_buffer failed");
+ err = EMAIL_ERROR_KEY_MANAGER_FAILURE;
+ goto FINISH_OFF;
+
+ }
+
+ alias = __get_key_manager_alias(data_name);
+ ckmc_ret = ckmc_decrypt_data(params, alias, NULL, *encrypted, &decrypted);
+ if (ckmc_ret != CKMC_ERROR_NONE) {
+
+ EM_DEBUG_LOG("ckmc_encrypt_data failed");
+ err = EMAIL_ERROR_KEY_MANAGER_FAILURE;
+ goto FINISH_OFF;
+
+ }
+
+ *output_data = (char *)decrypted->data;
+ *output_length = decrypted->size;
+
+ if (decrypted->data != NULL)
+ decrypted->data = NULL;
+
+
+
+
+
+FINISH_OFF:
+
+ if (encrypted != NULL)
+ ckmc_buffer_free(encrypted);
+
+
+ if (decrypted != NULL)
+ ckmc_buffer_free(decrypted);
+
+ if (params != NULL)
+ ckmc_param_list_free(params);
+
+
+ EM_SAFE_CLOSE(fd);
+ EM_SAFE_FREE(alias);
+ EM_DEBUG_FUNC_END();
+ return err;
+}
+
+
#ifndef __EMAIL_CORE_KEY_MANAGER_H__
#define __EMAIL_CORE_KEY_MANAGER_H__
+
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
INTERNAL_FUNC int emcore_add_password_in_key_manager(char *data_name, char *stored_data);
INTERNAL_FUNC int emcore_get_password_in_key_manager(char *data_name, char **stored_data);
INTERNAL_FUNC int emcore_remove_password_in_key_manager(char *data_name);
-INTERNAL_FUNC int emcore_get_certificate_in_key_manager(char *alias, char *password,
- const unsigned char **cert_data,
+INTERNAL_FUNC int emcore_get_certificate_in_key_manager(char *alias, char *password,
+ const unsigned char **cert_data,
int *cert_size);
+INTERNAL_FUNC int emcore_check_key_in_key_manager(const char *alias);
+INTERNAL_FUNC int emcore_save_key_in_key_manager(const char *alias);
+INTERNAL_FUNC int emcore_encryption_data_in_key_manager(const char *data_name, char *input_data, int input_length, unsigned char **output_data, int *output_length);
+INTERNAL_FUNC int emcore_decryption_data_from_file_in_key_manager(const char *data_name, const char *file_path, char **output_data, int *output_length);
#ifdef __cplusplus
}
#endif /* __cplusplus */
BuildRequires: pkgconfig(libtzplatform-config)
BuildRequires: pkgconfig(libsmack)
BuildRequires: pkgconfig(sqlite3)
+BuildRequires: pkgconfig(cryptsvc)
Requires: libtzplatform-config
-# OS update
+# OS upgrade
%define upgrade_script_path /usr/share/upgrade/scripts
%define upgrade_data_path /usr/share/upgrade/data
rm -rf %{_datarootdir}/license/email-service
fi
-# OS update
+# OS upgrade
mkdir -p %{buildroot}%{upgrade_script_path}
mkdir -p %{buildroot}%{upgrade_data_path}
cp -f 500.%{name}.patch.sh %{buildroot}%{upgrade_script_path}
%attr(0775,root,root) /etc/rc.d/init.d/email-service
%{_bindir}/email-service_init_db.sh
-# OS update
+# OS upgrade
%{upgrade_script_path}/500.%{name}.patch.sh
%{upgrade_data_path}/%{name}.sql
static gboolean testapp_test_backup_account()
{
- char *file_name = (char *)tzplatform_mkpath(TZ_SYS_DATA, "email/accounts_file");
+ const char *file_name = tzplatform_mkpath(TZ_USER_DATA, "email/accounts_file");
int error_code;
error_code = email_backup_accounts_into_secure_storage(file_name);
testapp_print("\n email_backup_accounts_into_secure_storage returned [%d]\n", error_code);
}
static gboolean testapp_test_restore_account()
{
- char *file_name = (char *)tzplatform_mkpath(TZ_SYS_DATA,"email/accounts_file");
+ const char *file_name = tzplatform_mkpath(TZ_USER_DATA,"email/accounts_file");
int error_code;
error_code = email_restore_accounts_from_secure_storage(file_name);
testapp_print("\n email_restore_accounts_from_secure_storage returned [%d]\n", error_code);
projects / platform / core / messaging / email-service.git / commitdiff