/**
* @brief Callback for getting user's input regarding mutual verification.
- * @return @c true true in cse of confirmed, otherwise @c false
+ * @return @c true in case of confirmed, otherwise @c false
*/
typedef bool (*st_things_user_confirm_cb) (void);
* If multiple callbacks are set, the last one is registered only.\n
* And the callbacks are called in the internal thread, which is not detached,\n
* so application should return it to get the next callbacks.
- * @param[in] status_cb Refernce of the callback function to get ST Things status
+ * @param[in] status_cb Reference of the callback function to get ST Things status
* @return @c 0 on success, otherwise a negative error value
* @retval #ST_THINGS_ERROR_NONE Successful
* @retval #ST_THINGS_ERROR_INVALID_PARAMETER Invalid parameter
/**
* @brief Structure for Representation.
*/
-typedef struct _st_things_representation
-{
+typedef struct _st_things_representation {
void* payload; /**< Payload of representation */
/**
/**
* @brief Structure for representing the Get Request Message.
*/
-typedef struct _st_things_get_request_message
-{
+typedef struct _st_things_get_request_message {
char* resource_uri; /**< Resource URI */
char* query; /**< One or more query parameters of the request message. Ex: key1=value1;key2=value2;... */
char* property_key; /**< One or more property key that application needs to set a value for response. Ex: key1;key2;... */
/**
* @brief Structure for representing the Set Request Message.
*/
-typedef struct _st_things_set_request_message
-{
+typedef struct _st_things_set_request_message {
char* resource_uri; /**< Resource URI */
char* query; /**< One or more query parameters of the request message. Ex: key1=value1?key2=value2?... */
struct _st_things_representation* rep; /**< Representation of the set request message */
* This file contains the exported symbol.
*/
#include <glib.h>
+#include <stdio.h>
#include "fmwup_api.h"
#include "fmwup_util_log.h"
char *g_download_path = NULL;
+
int _fmwup_get_data(st_things_representation_s *resp_rep)
{
FN_CALL;
G_FREE(fmwup_data->new_version);
G_FREE(fmwup_data->package_uri);
G_FREE(fmwup_data->package_md5);
+ G_FREE(fmwup_data->current_version);
G_FREE(fmwup_data->manufacturer);
G_FREE(fmwup_data->model_name);
- G_FREE(fmwup_data->current_version);
G_FREE(fmwup_data);
FN_END;
char *description = NULL;
int64_t update;
- char temp[KEY_MANAGER_MAX_DATA_LENGTH] = {0,};
-
/* write to non volatile data - package info */
if (req_msg->rep->get_str_value(req_msg->rep, FIRMWARE_PROPERTY_NEW_VERSION, &new_firmware)) {
DBG("new_firmware: [%s]", new_firmware);
if (req_msg->rep->get_int_value(req_msg->rep, FIRMWARE_PROPERTY_PACKAGE_SIZE, &package_size)) {
DBG("package_size: [%lld]", package_size);
- snprintf(temp, sizeof(temp), "%lld", package_size);
- if (0 != fmwup_data_set_property(FIRMWARE_PROPERTY_PACKAGE_SIZE, temp)) {
+ if (0 != fmwup_data_set_property_int64(FIRMWARE_PROPERTY_PACKAGE_SIZE, package_size)) {
ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_PACKAGE_SIZE);
}
}
if (req_msg->rep->get_int_value(req_msg->rep, FIRMWARE_PROPERTY_UPDATE, &update)) {
DBG("update: [%lld]", update);
- snprintf(temp, sizeof(temp), "%lld", update);
- if (0 != fmwup_data_set_property(FIRMWARE_PROPERTY_UPDATE, temp)) {
+ if (0 != fmwup_data_set_property_int64(FIRMWARE_PROPERTY_UPDATE, update)) {
ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_UPDATE);
}
if (0 == g_strcmp0(req_msg->resource_uri, FIRMWARE_URI)) {
_fmwup_get_data(resp_rep);
+ fmwup_internal_propagate_cond_signal();
} else {
INFO("response [%s] uri not exist", FIRMWARE_URI);
}
if (0 == g_strcmp0(req_msg->resource_uri, FIRMWARE_URI))
{
_fmwup_set_data(req_msg, resp_rep);
+ _fmwup_get_data(resp_rep);
+
} else {
INFO("request [%s] uri not exist", FIRMWARE_URI);
}
int fmwup_update(fmwup_update_e command, char *update_time)
{
FN_CALL;
- int ret = 0;
if (command == FMWUP_COMMAND_SCHEDULED_UPDATE) {
if (!update_time) {
return FMWUP_ERROR_INVALID_PARAMETER;
}
- ret = st_things_notify_observers(FIRMWARE_URI);
- if (0 == ret) {
- ERR("Failed fmwup_set_data [%d]", ret);
- return ret;
- }
-
FN_END;
return FMWUP_ERROR_NONE;
}
int fmwup_check_firmware_upgraded(void)
{
FN_CALL;
-
char *temp_state = fmwup_data_get_property(FIRMWARE_PROPERTY_STATE);
- int state = FMWUP_STATE_IDLE;
- if (!state) {
+ if (!temp_state) {
ERR("failed to get state property");
return FMWUP_ERROR_OPERATION_FAILED;
}
+ int state = FMWUP_STATE_IDLE;
state = atoi(temp_state);
G_FREE(temp_state);
fmwup_data_set_property(FIRMWARE_PROPERTY_PACKAGE_MD5, KEY_MANAGER_STR_DEFAULT_DATA);
fmwup_data_set_property(FIRMWARE_PROPERTY_PACKAGE_SIZE, KEY_MANAGER_INT_DEFAULT_DATA);
- fmwup_propagate_firmware_status_resource(FMWUP_STATE_IDLE, FMWUP_RESULT_SUCCESS);
+ fmwup_internal_propagate_resource(FMWUP_STATE_IDLE, FMWUP_RESULT_SUCCESS, false);
} else {
ERR("is not updating, state[%d]", state);
#include <ckmc/ckmc-manager.h>
#include <system_info.h>
#include <stdlib.h>
+#include <stdio.h>
#include "fmwup_util_log.h"
static bool g_active_check = false;
+static pthread_mutex_t g_data_key_manager_mutex = PTHREAD_MUTEX_INITIALIZER;
+
int key_manager_set_data(const char *name, char *data)
{
ckmc_policy.password = NULL;
ckmc_policy.extractable = true;
- ret = ckmc_remove_alias(name);
+ char *key_manager_name = g_strconcat(KEY_MANAGER_DATA_UNIQUE_NAME, name, NULL);
+
+ pthread_mutex_lock(&g_data_key_manager_mutex);
+ ret = ckmc_remove_alias(key_manager_name);
if (ret != CKMC_ERROR_NONE && ret != CKMC_ERROR_DB_ALIAS_UNKNOWN) {
ERR("ckmc_remove_data failed [%x]", ret);
- return -1;
}
- char *key_manager_name = g_strconcat(KEY_MANAGER_DATA_UNIQUE_NAME, name, NULL);
-
ret = ckmc_save_data(key_manager_name, ckmc_raw_buffer, ckmc_policy);
+ pthread_mutex_unlock(&g_data_key_manager_mutex);
if (ret != CKMC_ERROR_NONE) {
ERR("ckmc_save_data failed [%x]", ret);
G_FREE(key_manager_name);
} else if (g_strcmp0(name, FIRMWARE_PROPERTY_DESCRIPTION) == 0) {
default_data = g_strdup(KEY_MANAGER_STR_DEFAULT_DATA);
} else if (g_strcmp0(name, FIRMWARE_PROPERTY_STATE) == 0) {
- default_data = g_strdup(KEY_MANAGER_STR_DEFAULT_DATA);
+ default_data = g_strdup(KEY_MANAGER_INT_DEFAULT_DATA);
} else if (g_strcmp0(name, FIRMWARE_PROPERTY_RESULT) == 0) {
default_data = g_strdup(KEY_MANAGER_INT_DEFAULT_DATA);
} else if (g_strcmp0(name, FIRMWARE_PROPERTY_PROGRESS) == 0) {
char *key_manager_name = g_strconcat(KEY_MANAGER_DATA_UNIQUE_NAME, name, NULL);
- ret = ckmc_get_data(name, NULL, &ckmc_raw_buffer);
+ pthread_mutex_lock(&g_data_key_manager_mutex);
+ ret = ckmc_get_data(key_manager_name, NULL, &ckmc_raw_buffer);
+ pthread_mutex_unlock(&g_data_key_manager_mutex);
+
if (ret != CKMC_ERROR_NONE) {
ERR("ckmc_get_data failed [%x]", ret);
G_FREE(key_manager_name);
int key_manager_remove_data(const char *name)
{
+ char *key_manager_name = g_strconcat(KEY_MANAGER_DATA_UNIQUE_NAME, name, NULL);
+
int ret = CKMC_ERROR_NONE;
- ret = ckmc_remove_alias(name);
+ pthread_mutex_lock(&g_data_key_manager_mutex);
+ ret = ckmc_remove_alias(key_manager_name);
+ pthread_mutex_unlock(&g_data_key_manager_mutex);
if (ret != CKMC_ERROR_NONE) {
+ G_FREE(key_manager_name);
ERR("ckmc_remove_data failed [%x]", ret);
return -1;
}
+ G_FREE(key_manager_name);
return 0;
}
return NULL;
}
- /* TODO: for test - check correct key */
- char *temp_char = NULL;
-
- if (system_info_get_platform_string("http://tizen.org/system/manufacturer", &temp_char)
- != SYSTEM_INFO_ERROR_NONE) {
- ERR("system_info_get_platform_string() is failed");
- } else {
- INFO("http://tizen.org/system/manufacturer[%s]", temp_char);
- G_FREE(temp_char);
- }
-
- if (system_info_get_platform_string("http://tizen.org/system/model_name", &temp_char)
- != SYSTEM_INFO_ERROR_NONE) {
- ERR("system_info_get_platform_string() is failed");
- } else {
- INFO("http://tizen.org/system/model_name[%s]", temp_char);
- G_FREE(temp_char);
- }
-
- if (system_info_get_platform_string("http://tizen.org/system/build.version.release", &temp_char)
- != SYSTEM_INFO_ERROR_NONE) {
- ERR("system_info_get_platform_string() is failed");
- } else {
- INFO("http://tizen.org/system/build.version.release[%s]", temp_char);
- G_FREE(temp_char);
- }
-
- if (system_info_get_platform_string("http://tizen.org/system/platform.name", &temp_char)
- != SYSTEM_INFO_ERROR_NONE) {
- ERR("system_info_get_platform_string() is failed");
- } else {
- INFO("http://tizen.org/system/platform.name[%s]", temp_char);
- G_FREE(temp_char);
- }
-
- if (system_info_get_platform_string("http://tizen.org/feature/platform.version", &temp_char)
- != SYSTEM_INFO_ERROR_NONE) {
- ERR("system_info_get_platform_string() is failed");
- } else {
- INFO("http://tizen.org/feature/platform.version[%s]", temp_char);
- G_FREE(temp_char);
- }
-
- if (system_info_get_platform_string("http://tizen.org/feature/platform.version.name", &temp_char)
- != SYSTEM_INFO_ERROR_NONE) {
- ERR("system_info_get_platform_string() is failed");
- } else {
- INFO("http://tizen.org/feature/platform.version.name[%s]", temp_char);
- G_FREE(temp_char);
- }
-
-
char *data = NULL;
int system_ret = 0;
fmwup_get_data->active_check = get_active_check();
+
+
+
+
+ /* TODO: for test - check correct key */
+ char *temp_char = NULL;
+
+ if (system_info_get_platform_string("http://tizen.org/system/manufacturer", &temp_char)
+ != SYSTEM_INFO_ERROR_NONE) {
+ ERR("system_info_get_platform_string() is failed");
+ } else {
+ INFO("http://tizen.org/system/manufacturer[%s]", temp_char);
+ G_FREE(temp_char);
+ }
+
+ if (system_info_get_platform_string("http://tizen.org/system/model_name", &temp_char)
+ != SYSTEM_INFO_ERROR_NONE) {
+ ERR("system_info_get_platform_string() is failed");
+ } else {
+ INFO("http://tizen.org/system/model_name[%s]", temp_char);
+ G_FREE(temp_char);
+ }
+
+ if (system_info_get_platform_string("http://tizen.org/system/build.version.release", &temp_char)
+ != SYSTEM_INFO_ERROR_NONE) {
+ ERR("system_info_get_platform_string() is failed");
+ } else {
+ INFO("http://tizen.org/system/build.version.release[%s]", temp_char);
+ G_FREE(temp_char);
+ }
+
+ if (system_info_get_platform_string("http://tizen.org/system/platform.name", &temp_char)
+ != SYSTEM_INFO_ERROR_NONE) {
+ ERR("system_info_get_platform_string() is failed");
+ } else {
+ INFO("http://tizen.org/system/platform.name[%s]", temp_char);
+ G_FREE(temp_char);
+ }
+
+ if (system_info_get_platform_string("http://tizen.org/feature/platform.version", &temp_char)
+ != SYSTEM_INFO_ERROR_NONE) {
+ ERR("system_info_get_platform_string() is failed");
+ } else {
+ INFO("http://tizen.org/feature/platform.version[%s]", temp_char);
+ G_FREE(temp_char);
+ }
+
+ if (system_info_get_platform_string("http://tizen.org/feature/platform.version.name", &temp_char)
+ != SYSTEM_INFO_ERROR_NONE) {
+ ERR("system_info_get_platform_string() is failed");
+ } else {
+ INFO("http://tizen.org/feature/platform.version.name[%s]", temp_char);
+ G_FREE(temp_char);
+ }
+
+
+
+
+
FN_END;
- return &fmwup_get_data;
+ return fmwup_get_data;
+}
+
+
+int fmwup_data_set_property_int64(const char *name, int64_t data)
+{
+ if (!name) {
+ ERR("name is NULL");
+ return -1;
+ }
+
+ char temp[KEY_MANAGER_MAX_DATA_LENGTH] = {0,};
+ snprintf(temp, sizeof(temp), "%lld", data);
+
+ return (fmwup_data_set_property(name, temp));
}
return -1;
}
- DBG("key [%s]", name, data);
+ DBG("key [%s], data[%s]", name, data);
if (
(g_strcmp0(name, FIRMWARE_PROPERTY_UPDATE) == 0)
// || (g_strcmp0(name, FIRMWARE_PROPERTY_MODEL) == 0)
) {
//TOOD: how to set current version to platform.
+ INFO("set version to platform[%s]", data);
return platform_set_data(name, data);
} else if (g_strcmp0(name, FIRMWARE_PROPERTY_ACTIVE_CHECK) == 0) {
if (g_strcmp0(name, "true") == 0)
return g_strdup("false");
} else {
ERR("Invalid key[%s]", name);
- return -1;
+ return NULL;
}
- return 0;
+ return NULL;
}
#define KEY_MANAGER_MAX_DATA_LENGTH 200
#define KEY_MANAGER_INT_DEFAULT_DATA "0"
-#define KEY_MANAGER_STR_DEFAULT_DATA ""
+#define KEY_MANAGER_STR_DEFAULT_DATA " "
#define KEY_MANAGER_BOL_DEFAULT_DATA "0"
typedef struct {
//bool get_active_check();
fmwup_data_s *fmwup_data_get_properties();
+int fmwup_data_set_property_int64(const char *name, int64_t data);
int fmwup_data_set_property(const char *name, char *data);
char *fmwup_data_get_property(const char *name);
#include <glib.h>
#include <stdlib.h>
#include <stdio.h>
+#include <sys/time.h>
#include "fmwup_util_log.h"
#include "fmwup_util_http.h"
#define UPDATE_FILE "/opt/usr/data/fota/tota_init"
#define FIRMWARE_FILE_NAME "fmwup.zip"
+#define TIMEOUT_SEC 5
+
extern char *g_download_path;
extern fmwup_state_changed_cb g_state_changed_cb;
-int _fmwup_propagate_firmware_resource(void)
+static int g_thread_running = 0;
+
+/* initializing a condition variable when declare */
+/* if you want to be initialized at runtime, call the pthread_cond_init() */
+static pthread_mutex_t _lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t _cond = PTHREAD_COND_INITIALIZER;
+
+void fmwup_internal_propagate_timed_wait()
{
- int ret = 0;
- ret = st_things_notify_observers(FIRMWARE_URI);
- if (0 == ret) {
- ERR("Failed st_things_notify_observers [%d]", ret);
+ FN_CALL;
+ struct timeval now; /* start time to wait */
+ struct timespec timeout; /* timeout value in waiting function */
+ struct timezone zone;
+ pthread_mutex_lock(&_lock);
+
+ gettimeofday(&now, &zone);
+ timeout.tv_sec = now.tv_sec + TIMEOUT_SEC;
+ timeout.tv_nsec = now.tv_usec * 1000;
+ /* timeval = microsecond */
+ /* timespec = nanosecond */
+ /* 1 nano = 1000 micro */
+
+ int rc = pthread_cond_timedwait(&_cond, &_lock, &timeout);
+ switch(rc) {
+ case 0:
+ break;
+ case ETIMEDOUT:
+ ERR("timeout %d second", TIMEOUT_SEC);
+ break;
+ default:
+ ERR("failed pthread_cond_timedwait [%d]", rc);
+ break;
}
- return ret;
+ pthread_mutex_unlock(&_lock);
}
-void fmwup_propagate_firmware_status_resource(fmwup_state_e state, fmwup_result_e result)
+void fmwup_internal_propagate_cond_signal()
+{
+ FN_CALL;
+ pthread_mutex_lock(&_lock);
+ pthread_cond_signal(&_cond);
+ pthread_mutex_unlock(&_lock);
+}
+
+void fmwup_internal_propagate_resource(fmwup_state_e state, fmwup_result_e result, bool wait_flag)
{
DBG("Propagate state[%d], result[%d]", state, result);
int ret = 0;
- char temp_data[KEY_MANAGER_MAX_DATA_LENGTH] = {0,};
+ fmwup_data_set_property_int64(FIRMWARE_PROPERTY_STATE, (int64_t)state);
+ fmwup_data_set_property_int64(FIRMWARE_PROPERTY_RESULT, (int64_t)result);
- snprintf(temp_data, KEY_MANAGER_MAX_DATA_LENGTH, "%d", state);
- fmwup_data_set_property(FIRMWARE_PROPERTY_STATE, temp_data);
-
- snprintf(temp_data, KEY_MANAGER_MAX_DATA_LENGTH, "%d", result);
- fmwup_data_set_property(FIRMWARE_PROPERTY_RESULT, temp_data);
-
- ret = _fmwup_propagate_firmware_resource();
- if (0 == ret) {
- ERR("Failed propagate [%d]", ret);
+ ret = st_things_notify_observers(FIRMWARE_URI);
+ if (ST_THINGS_ERROR_NONE != ret) {
+ ERR("Failed st_things_notify_observers [%d]", ret);
+ return;
}
- if (g_state_changed_cb) {
+ if (wait_flag)
+ fmwup_internal_propagate_timed_wait();
+
+ if (g_state_changed_cb)
g_state_changed_cb(state, result);
- }
if (result != FMWUP_RESULT_INIT) {
//init state, result in failed case
- snprintf(temp_data, KEY_MANAGER_MAX_DATA_LENGTH, "%d", FMWUP_STATE_IDLE);
- fmwup_data_set_property(FIRMWARE_PROPERTY_STATE, temp_data);
-
- snprintf(temp_data, KEY_MANAGER_MAX_DATA_LENGTH, "%d", FMWUP_RESULT_INIT);
- fmwup_data_set_property(FIRMWARE_PROPERTY_RESULT, temp_data);
-
-// ret = _fmwup_propagate_firmware_resource();
-// if (0 == ret) {
-// ERR("Failed propagate [%d]", ret);
-// }
+ fmwup_data_set_property_int64(FIRMWARE_PROPERTY_STATE, (int64_t)FMWUP_STATE_IDLE);
+ fmwup_data_set_property_int64(FIRMWARE_PROPERTY_RESULT, (int64_t)FMWUP_RESULT_INIT);
}
}
return true;
}
-void _fmwup_handle_update_command(int64_t update_type)
+void _handle_update_command(int64_t update_type)
{
int result = FMWUP_RESULT_INIT;
#ifdef _USE_WWST_
if ((state == FMWUP_STATE_IDLE) && (update_type == FMWUP_COMMAND_DOWNLOAD_IMAGE || update_type == FMWUP_COMMAND_DOWNLOAD_IMAGE_AND_UPDATE)) {
DBG("***Downloading image from [%s] ***", package_uri);
- fmwup_propagate_firmware_status_resource(FMWUP_STATE_DOWNLOADING, FMWUP_RESULT_INIT);
+ state = FMWUP_STATE_DOWNLOADING;
+ fmwup_internal_propagate_resource(FMWUP_STATE_DOWNLOADING, FMWUP_RESULT_INIT, true);
#ifdef _USE_WWST_
result = FMWUP_RESULT_INVALID_URI;
goto _END_OF_FUNC_;
} else {
- //parsing
INFO("res_header[%s] res_body[%s]",res_header, res_body);
+ /* parsing url */
+ /* {"url":"https://iotm-dev-fota.s3-a...} */
if (_parse_secure_url(res_body, &sec_download_url)) {
INFO("download url[%s] download path[%s]",sec_download_url, download_path);
#endif
DBG("*** Firmware image downloaded ***");
- fmwup_propagate_firmware_status_resource(FMWUP_STATE_DOWNLOADED, FMWUP_RESULT_INIT);
+ state = FMWUP_STATE_DOWNLOADED;
+ fmwup_internal_propagate_resource(FMWUP_STATE_DOWNLOADED, FMWUP_RESULT_INIT, true);
}
if ((state == FMWUP_STATE_DOWNLOADED) &&
(update_type == FMWUP_COMMAND_UPDATE_BY_DOWNLOADED_IMAGE || update_type == FMWUP_COMMAND_DOWNLOAD_IMAGE_AND_UPDATE)) {
- fmwup_propagate_firmware_status_resource(FMWUP_STATE_UPDATING, FMWUP_RESULT_INIT);
+ state = FMWUP_STATE_UPDATING;
+ fmwup_internal_propagate_resource(FMWUP_STATE_UPDATING, FMWUP_RESULT_INIT, true);
//TODO: To upgrade using interface of fota-client
_exec_update();
_END_OF_FUNC_:
if (result != FMWUP_RESULT_INIT) {
INFO("propagate err[%d]", result);
- fmwup_propagate_firmware_status_resource(FMWUP_STATE_IDLE, result);
+ state = FMWUP_STATE_IDLE;
+ fmwup_internal_propagate_resource(FMWUP_STATE_IDLE, result, true);
}
#ifdef _USE_WWST_
return;
}
-void *_fmwup_worker(void *data)
+void *_update_worker(void *data)
{
int64_t exec_type = *(int64_t *)data;
- _fmwup_handle_update_command(exec_type);
+ _handle_update_command(exec_type);
G_FREE(data);
+ pthread_mutex_lock(&_lock);
+ g_thread_running = 0;
+ pthread_mutex_unlock(&_lock);
+
return NULL;
}
int fmwup_internal_update_command(int64_t update_type)
{
+ pthread_mutex_lock(&_lock);
+
+ if (g_thread_running) {
+ /* Allow only one running thread */
+ pthread_mutex_unlock(&_lock);
+ INFO("duplicated request");
+ return FMWUP_ERROR_NONE;
+ } else {
+ g_thread_running = 1;
+ }
+
+ pthread_mutex_unlock(&_lock);
+
int64_t *update = (int64_t *)calloc(1, sizeof(int64_t));
if (!update) {
ERR("Memory allocation error!");
*update = update_type;
pthread_t pThread;
- pthread_create(&pThread, NULL, _fmwup_worker, update);
+ pthread_create(&pThread, NULL, _update_worker, update);
return FMWUP_ERROR_NONE;
}
-
#include "fmwup_api.h"
-void fmwup_propagate_firmware_status_resource(fmwup_state_e state, fmwup_result_e result);
+void fmwup_internal_propagate_timed_wait();
+void fmwup_internal_propagate_cond_signal();
+
+void fmwup_internal_propagate_resource(fmwup_state_e state, fmwup_result_e result, bool wait_flag);
int fmwup_internal_update_command(int64_t update_type);
#endif /* FMWUP_UTIL_INTERNAL_H_ */
projects / platform / core / service / cloud / ua-client.git / commitdiff