<listOptionValue builtIn="false" value="TIZEN_DEPRECATION"/>
<listOptionValue builtIn="false" value="DEPRECATION_WARNING"/>
<listOptionValue builtIn="false" value="_DEBUG"/>
+ <listOptionValue builtIn="false" value="_USE_WWST_=_USE_WWST_"/>
</option>
<inputType id="cdt.managedbuild.tool.gnu.cpp.compiler.input.88951645" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.input"/>
</tool>
<listOptionValue builtIn="false" value="TIZEN_DEPRECATION"/>
<listOptionValue builtIn="false" value="DEPRECATION_WARNING"/>
<listOptionValue builtIn="false" value="_DEBUG"/>
+ <listOptionValue builtIn="false" value="_USE_WWST_=_USE_WWST_"/>
</option>
<inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.2106397814" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/>
</tool>
<option id="gnu.cpp.link.option.paths.2127407685" name="Library search path (-L)" superClass="gnu.cpp.link.option.paths" valueType="libPaths">
<listOptionValue builtIn="false" value=""${workspace_loc:/${ProjName}/lib}""/>
</option>
+ <option id="gnu.cpp.link.option.libs.534068022" name="Libraries (-l)" superClass="gnu.cpp.link.option.libs" valueType="libs">
+ <listOptionValue builtIn="false" srcPrefixMapping="" srcRootPath="" value="sdkapi"/>
+ </option>
<inputType id="cdt.managedbuild.tool.gnu.cpp.linker.input.1734114204" superClass="cdt.managedbuild.tool.gnu.cpp.linker.input">
<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
<additionalInput kind="additionalinput" paths="$(LIBS)"/>
<option id="sbi.gnu.cpp.compiler.option.frameworks.core.324855741" name="Tizen-Frameworks" superClass="sbi.gnu.cpp.compiler.option.frameworks.core" valueType="userObjs">
<listOptionValue builtIn="false" value="Native_API"/>
</option>
+ <option id="sbi.gnu.cpp.compiler.option.preprocessor.def.deprecation.740506885" superClass="sbi.gnu.cpp.compiler.option.preprocessor.def.deprecation" valueType="definedSymbols">
+ <listOptionValue builtIn="false" value="TIZEN_DEPRECATION"/>
+ <listOptionValue builtIn="false" value="DEPRECATION_WARNING"/>
+ <listOptionValue builtIn="false" value="_USE_WWST_=_USE_WWST_"/>
+ </option>
<inputType id="cdt.managedbuild.tool.gnu.cpp.compiler.input.342932899" superClass="cdt.managedbuild.tool.gnu.cpp.compiler.input"/>
</tool>
<tool command="clang" id="org.tizen.nativecore.tool.sbi.gnu.c.compiler.1771217314" name="C Compiler" superClass="org.tizen.nativecore.tool.sbi.gnu.c.compiler">
<option id="sbi.gnu.c.compiler.option.frameworks.core.752867410" name="Tizen-Frameworks" superClass="sbi.gnu.c.compiler.option.frameworks.core" valueType="userObjs">
<listOptionValue builtIn="false" value="Native_API"/>
</option>
+ <option id="sbi.gnu.c.compiler.option.preprocessor.def.symbols.deprecation.2066869501" superClass="sbi.gnu.c.compiler.option.preprocessor.def.symbols.deprecation" valueType="definedSymbols">
+ <listOptionValue builtIn="false" value="TIZEN_DEPRECATION"/>
+ <listOptionValue builtIn="false" value="DEPRECATION_WARNING"/>
+ <listOptionValue builtIn="false" value="_USE_WWST_=_USE_WWST_"/>
+ </option>
<inputType id="cdt.managedbuild.tool.gnu.c.compiler.input.1056387077" superClass="cdt.managedbuild.tool.gnu.c.compiler.input"/>
</tool>
<tool id="org.tizen.nativeide.tool.sbi.gnu.c.linker.base.927082769" name="C Linker" superClass="org.tizen.nativeide.tool.sbi.gnu.c.linker.base"/>
<projects>
</projects>
<buildSpec>
+ <buildCommand>
+ <name>org.tizen.nativecore.apichecker.apicheckerbuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
<buildCommand>
<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
<arguments>
<nature>org.eclipse.cdt.core.ccnature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+ <nature>org.tizen.nativecore.apichecker.apicheckernature</nature>
</natures>
<filteredResources>
<filter>
*/
#include <stdbool.h>
#include <tizen.h>
+#include "st_things.h"
#include "st_things_types.h"
#ifdef __cplusplus
*/
typedef enum {
FMWUP_ERROR_NONE = 0, /**< Successful */
- FMWUP_ERROR_INVALID_PARAMETER = -1, /**< Invalid parameter (If parameter is null or empty)*/
- FMWUP_ERROR_OPERATION_FAILED = -2, /**< Operation Failed */
+ FMWUP_ERROR_INVALID_PARAMETER = ST_THINGS_ERROR_INVALID_PARAMETER, /**< Invalid parameter (If parameter is null or empty)*/
+ FMWUP_ERROR_OPERATION_FAILED = ST_THINGS_ERROR_OPERATION_FAILED, /**< Operation Failed */
+ FMWUP_ERROR_MEMORY_ERR = -3, /**< Allocation Failed */
} fmwup_things_error_e;
} fmwup_update_e;
-typedef void (*fmwup_state_changed_cb)(fmwup_state_e value);
+typedef void (*fmwup_state_changed_cb)(fmwup_state_e state, fmwup_result_e result);
typedef void (*fmwup_is_new_firmware_cb)(bool is_new_firmware);
+++ /dev/null
-/*
- * fmwup_log.h
- *
- * Created on: Oct 11, 2017
- * Author: hhk86heo
- */
-
-#ifndef FMWUP_LOG_H_
-#define FMWUP_LOG_H_
-
-#include <dlog.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "ST-THINGS-APP"
-
-#define ERR(fmt, args...) dlog_print(DLOG_ERROR, LOG_TAG, fmt"\n", ##args)
-#define WARN(fmt, args...) dlog_print(DLOG_WARN, LOG_TAG, fmt"\n", ##args)
-#define INFO(fmt, args...) dlog_print(DLOG_INFO, LOG_TAG, fmt"\n", ##args)
-#define DBG(fmt, args...) dlog_print(DLOG_DEBUG, LOG_TAG, fmt"\n", ##args)
-
-#define FN_CALL dlog_print(DLOG_DEBUG, LOG_TAG, ">>>>>>>> called")
-#define FN_END dlog_print(DLOG_DEBUG, LOG_TAG, "<<<<<<<< ended")
-
-#ifdef __cplusplus
-}
-#endif
-
-
-
-
-#endif /* FMWUP_LOG_H_ */
/**
* This file contains the exported symbol.
*/
+#include <glib.h>
+
#include "fmwup_api.h"
+#include "fmwup_util_log.h"
+#include "fmwup_util_data.h"
+#include "fmwup_util_internal.h"
+#include "st_things.h"
+
+fmwup_state_changed_cb g_state_changed_cb = NULL;
+fmwup_is_new_firmware_cb g_is_new_cb = NULL;
+char *g_download_path = NULL;
+
+
+int _fmwup_get_data(st_things_representation_s *resp_rep)
+{
+ FN_CALL;
+ if (!resp_rep) {
+ ERR("Inavlid parameter, response representation is NULL");
+ return FMWUP_ERROR_INVALID_PARAMETER;
+ }
+
+ fmwup_data_s *fmwup_data;
+ fmwup_data = fmwup_data_get_properties();
+
+ /* save to key manager(ckmc) */
+ resp_rep->set_int_value(resp_rep, FIRMWARE_PROPERTY_UPDATE, (int64_t)fmwup_data->update);
+ resp_rep->set_str_value(resp_rep, FIRMWARE_PROPERTY_UPDATE_TIME, fmwup_data->update_time);
+ resp_rep->set_str_value(resp_rep, FIRMWARE_PROPERTY_DESCRIPTION, fmwup_data->description);
+ resp_rep->set_int_value(resp_rep, FIRMWARE_PROPERTY_STATE, (int64_t)fmwup_data->state);
+ resp_rep->set_int_value(resp_rep, FIRMWARE_PROPERTY_RESULT, (int64_t)fmwup_data->result);
+ resp_rep->set_int_value(resp_rep, FIRMWARE_PROPERTY_PROGRESS, (int64_t)fmwup_data->progress);
+
+ resp_rep->set_str_value(resp_rep, FIRMWARE_PROPERTY_NEW_VERSION, fmwup_data->new_version);
+ resp_rep->set_str_value(resp_rep, FIRMWARE_PROPERTY_PACKAGE_URI, fmwup_data->package_uri);
+ resp_rep->set_int_value(resp_rep, FIRMWARE_PROPERTY_PACKAGE_SIZE, (int64_t)fmwup_data->package_size);
+ resp_rep->set_str_value(resp_rep, FIRMWARE_PROPERTY_PACKAGE_MD5, fmwup_data->package_md5);
+
+ /* platform information */
+ resp_rep->set_str_value(resp_rep, FIRMWARE_PROPERTY_CURRENT_VERSION, fmwup_data->current_version);
+ resp_rep->set_str_value(resp_rep, FIRMWARE_PROPERTY_VENDER, fmwup_data->manufacturer);
+ resp_rep->set_str_value(resp_rep, FIRMWARE_PROPERTY_MODEL, fmwup_data->model_name);
+
+ /* temporary value */
+ resp_rep->set_bool_value(resp_rep, FIRMWARE_PROPERTY_ACTIVE_CHECK, fmwup_data->active_check);
+
+ G_FREE(fmwup_data->update_time);
+ G_FREE(fmwup_data->description);
+ G_FREE(fmwup_data->new_version);
+ G_FREE(fmwup_data->package_uri);
+ G_FREE(fmwup_data->package_md5);
+ G_FREE(fmwup_data->manufacturer);
+ G_FREE(fmwup_data->model_name);
+ G_FREE(fmwup_data->current_version);
+ G_FREE(fmwup_data);
+
+ FN_END;
+ return FMWUP_ERROR_NONE;
+}
+
+
+void _fmwup_set_data(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
+{
+ FN_CALL;
+ char *new_firmware = NULL;
+ char *package_uri = NULL;
+ char *package_md5 = NULL;
+ int64_t package_size = 0;
+
+ char *update_time = NULL;
+ 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 (0 != fmwup_data_set_property(FIRMWARE_PROPERTY_NEW_VERSION, new_firmware)) {
+ ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_NEW_VERSION);
+ }
+ }
+
+ if (req_msg->rep->get_str_value(req_msg->rep, FIRMWARE_PROPERTY_PACKAGE_URI, &package_uri)) {
+ DBG("package_uri: [%s]", package_uri);
+ if (0 != fmwup_data_set_property(FIRMWARE_PROPERTY_PACKAGE_URI, package_uri)) {
+ ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_PACKAGE_URI);
+ }
+ }
+
+ 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)) {
+ ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_PACKAGE_SIZE);
+ }
+ }
+
+ if (req_msg->rep->get_str_value(req_msg->rep, FIRMWARE_PROPERTY_PACKAGE_MD5, &package_md5)) {
+ DBG("package_md5: [%s]", package_md5);
+ if (0 != fmwup_data_set_property(FIRMWARE_PROPERTY_PACKAGE_MD5, package_md5)) {
+ ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_PACKAGE_MD5);
+ }
+ }
+
+ if (new_firmware && package_uri && g_is_new_cb)
+ g_is_new_cb(true);
+
+
+ /* write to volatile data - update info */
+
+ if (req_msg->rep->get_str_value(req_msg->rep, FIRMWARE_PROPERTY_UPDATE_TIME, &update_time)) {
+ DBG("update_time: [%s]", update_time);
+ if (0 != fmwup_data_set_property(FIRMWARE_PROPERTY_UPDATE_TIME, update_time)) {
+ ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_UPDATE_TIME);
+ }
+ /* TODO : Check Scheduled update , */
+ }
+
+ if (req_msg->rep->get_str_value(req_msg->rep, FIRMWARE_PROPERTY_DESCRIPTION, &description)) {
+ DBG("description: [%s]", description);
+ if (0 != fmwup_data_set_property(FIRMWARE_PROPERTY_DESCRIPTION, description)) {
+ ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_DESCRIPTION);
+ }
+ }
+
+ 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)) {
+ ERR("fmwup_data_set_property [%s] failed", FIRMWARE_PROPERTY_UPDATE);
+ }
+
+ fmwup_internal_update_command(update);
+ }
+
+ FN_END;
+}
+
+
+int fmwup_handle_get_request(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
+{
+ FN_CALL;
+ if (!resp_rep) {
+ ERR("Inavlid parameter, response representation is NULL");
+ return FMWUP_ERROR_INVALID_PARAMETER;
+ }
+
+ if (0 == g_strcmp0(req_msg->resource_uri, FIRMWARE_URI)) {
+ _fmwup_get_data(resp_rep);
+ } else {
+ INFO("response [%s] uri not exist", FIRMWARE_URI);
+ }
+
+ FN_END;
+ return FMWUP_ERROR_NONE;
+}
+
+
+
+int fmwup_handle_set_request(st_things_set_request_message_s *req_msg, st_things_representation_s *resp_rep)
+{
+ FN_CALL;
+ if (0 == g_strcmp0(req_msg->resource_uri, FIRMWARE_URI))
+ {
+ _fmwup_set_data(req_msg, resp_rep);
+ } else {
+ INFO("request [%s] uri not exist", FIRMWARE_URI);
+ }
+
+ FN_END;
+ return FMWUP_ERROR_NONE;
+}
+
+
+int fmwup_set_firmware_download_path(const char *download_path)
+{
+ FN_CALL;
+ if (!download_path) {
+ ERR("Inavlid download_path");
+ return FMWUP_ERROR_INVALID_PARAMETER;
+ }
+
+ G_FREE(g_download_path);
+ g_download_path = NULL;
+ g_download_path = g_strdup(download_path);
+ INFO("g_download_path [%s]", g_download_path);
+
+ FN_END;
+ return FMWUP_ERROR_NONE;
+}
+
+
+int fmwup_register_update_changed_cb(fmwup_state_changed_cb state_cb, fmwup_is_new_firmware_cb is_new_firmware_cb )
+{
+ FN_CALL;
+ if (NULL == state_cb) {
+ ERR("State callback is NULL.");
+ return FMWUP_ERROR_INVALID_PARAMETER;
+ }
+
+ if (NULL == is_new_firmware_cb) {
+ ERR("Isnewfirmware callback is NULL.");
+ return FMWUP_ERROR_INVALID_PARAMETER;
+ }
+
+ g_state_changed_cb = state_cb;
+ g_is_new_cb = is_new_firmware_cb;
+
+ FN_END;
+ return FMWUP_ERROR_NONE;
+}
+
+
+int fmwup_get_newest_firmware_from_server(void)
+{
+ FN_CALL;
+ int ret = 0;
+
+ ret = fmwup_data_set_property(FIRMWARE_PROPERTY_ACTIVE_CHECK, "true");
+ if (0 == ret) {
+ ERR("Failed fmwup_set_data [%d]", ret);
+ return FMWUP_ERROR_OPERATION_FAILED;
+ }
+
+ ret = st_things_notify_observers(FIRMWARE_URI);
+ if (0 == ret) {
+ ERR("Failed st_things_notify_observers [%d]", ret);
+ return ret;
+ }
+
+ FN_END;
+ return FMWUP_ERROR_NONE;
+}
+
+
+int fmwup_update(fmwup_update_e command, char *update_time)
+{
+ FN_CALL;
+ int ret = 0;
+
+ if (command == FMWUP_COMMAND_SCHEDULED_UPDATE) {
+ if (!update_time) {
+ ERR("Invalid parameter when SCHEDULED_UPDATE[%d]", command);
+ return FMWUP_ERROR_INVALID_PARAMETER;
+ }
+ /* TODO : logic for command */
+ } else if (FMWUP_COMMAND_INIT < command && FMWUP_COMMAND_DOWNLOAD_IMAGE_AND_UPDATE > command) {
+ /* TODO : logic for command */
+ return fmwup_internal_update_command((int64_t)command);
+ } else {
+ ERR("Invalid parameter command[%d]", command);
+ 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) {
+ ERR("failed to get state property");
+ return FMWUP_ERROR_OPERATION_FAILED;
+ }
+
+ state = atoi(temp_state);
+ G_FREE(temp_state);
+
+ if (state == FMWUP_STATE_UPDATING) {
+ DBG("***Firmware Upgrade Done***");
+
+ // TODO :: It should be checked and set result value according to upgrade result
+ /* Initialize - new platform information - */
+ char *new_version = fmwup_data_get_property(FIRMWARE_PROPERTY_NEW_VERSION);
+ if (new_version) {
+ fmwup_data_set_property(FIRMWARE_PROPERTY_CURRENT_VERSION, new_version);
+ G_FREE(new_version);
+ } else {
+ ERR("failed get new version");
+ }
+
+ /* Initialize - new firmware information - */
+ fmwup_data_set_property(FIRMWARE_PROPERTY_NEW_VERSION, KEY_MANAGER_STR_DEFAULT_DATA);
+ fmwup_data_set_property(FIRMWARE_PROPERTY_PACKAGE_URI, KEY_MANAGER_STR_DEFAULT_DATA);
+ 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);
-// This is an example of an exported method.
-//bool
-//tizenfmwup_api(void)
-//{
-// return true;
-//}
+ } else {
+ ERR("is not updating, state[%d]", state);
+ return FMWUP_ERROR_OPERATION_FAILED;
+ }
+ FN_END;
+ return FMWUP_ERROR_NONE;
+}
--- /dev/null
+/*
+ * fmwup_util_data.c
+ *
+ * Created on: Oct 17, 2017
+ * Author: hhk86heo
+ */
+
+#include "fmwup_util_data.h"
+
+#include <ckmc/ckmc-manager.h>
+#include <system_info.h>
+#include <stdlib.h>
+
+#include "fmwup_util_log.h"
+
+
+#define KEY_MANAGER_DATA_UNIQUE_NAME "FMWUP_API_KEY_MANAGER_"
+
+static bool g_active_check = false;
+
+
+int key_manager_set_data(const char *name, char *data)
+{
+ if (!name || !data) {
+ ERR("name or data is NULL");
+ if (name)
+ ERR("name [%s]", name);
+ if (data)
+ ERR("data [%s]", data);
+ return -1;
+ }
+
+ DBG("key[%s] data[%s]", name, data);
+
+ int ret = CKMC_ERROR_NONE;
+
+ ckmc_raw_buffer_s ckmc_raw_buffer;
+ ckmc_policy_s ckmc_policy;
+
+ ckmc_raw_buffer.data = (unsigned char *)data;
+ ckmc_raw_buffer.size = strnlen(data, KEY_MANAGER_MAX_DATA_LENGTH);
+
+ if (ckmc_raw_buffer.size == KEY_MANAGER_MAX_DATA_LENGTH) {
+ ERR("ckmc_raw_buffer overflow");
+ return -1;
+ }
+
+ ckmc_policy.password = NULL;
+ ckmc_policy.extractable = true;
+
+ ret = ckmc_remove_alias(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);
+ if (ret != CKMC_ERROR_NONE) {
+ ERR("ckmc_save_data failed [%x]", ret);
+ G_FREE(key_manager_name);
+ return -1;
+ }
+
+ G_FREE(key_manager_name);
+
+ return 0;
+}
+
+
+char *_key_manager_set_default_data(const char *name)
+{
+ if (!name) {
+ ERR("name is NULL");
+ return NULL;
+ }
+ DBG("key [%s]", name);
+
+ char *default_data = NULL;
+
+ if (g_strcmp0(name, FIRMWARE_PROPERTY_UPDATE) == 0) {
+ default_data = g_strdup(KEY_MANAGER_INT_DEFAULT_DATA);
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_UPDATE_TIME) == 0) {
+ default_data = g_strdup(KEY_MANAGER_STR_DEFAULT_DATA);
+ } 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);
+ } 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) {
+ default_data = g_strdup(KEY_MANAGER_INT_DEFAULT_DATA);
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_NEW_VERSION) == 0) {
+ default_data = g_strdup(KEY_MANAGER_STR_DEFAULT_DATA);
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_URI) == 0) {
+ default_data = g_strdup(KEY_MANAGER_STR_DEFAULT_DATA);
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_SIZE) == 0) {
+ default_data = g_strdup(KEY_MANAGER_INT_DEFAULT_DATA);
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_MD5) == 0) {
+ default_data = g_strdup(KEY_MANAGER_STR_DEFAULT_DATA);
+ } else {
+ ERR("Invalid key[%s]", name);
+ return NULL;
+ }
+
+ if (0 != key_manager_set_data(name, default_data))
+ ERR("failed set default data [%s]", name);
+
+ return default_data;
+}
+
+char *key_manager_get_data(const char *name)
+{
+ if (!name) {
+ ERR("name is NULL");
+ return NULL;
+ }
+ DBG("key [%s]", name);
+
+ int ret = CKMC_ERROR_NONE;
+ ckmc_raw_buffer_s *ckmc_raw_buffer = NULL;
+
+ char *key_manager_name = g_strconcat(KEY_MANAGER_DATA_UNIQUE_NAME, name, NULL);
+
+ ret = ckmc_get_data(name, NULL, &ckmc_raw_buffer);
+ if (ret != CKMC_ERROR_NONE) {
+ ERR("ckmc_get_data failed [%x]", ret);
+ G_FREE(key_manager_name);
+
+ if (ret == CKMC_ERROR_DB_ALIAS_UNKNOWN) {
+ return (_key_manager_set_default_data(name));
+ }
+
+ return NULL;
+ }
+ G_FREE(key_manager_name);
+
+ if (ckmc_raw_buffer == NULL) {
+ ERR("ckmc_raw_buffer is NULL");
+ return NULL;
+ }
+ if (ckmc_raw_buffer->data == NULL || ckmc_raw_buffer->size <= 0) {
+ ckmc_buffer_free(ckmc_raw_buffer);
+ ERR("ckmc_raw_buffer->data is NULL");
+ return NULL;
+ }
+
+ int len = (int)ckmc_raw_buffer->size;
+ char *text_data = g_strndup((char *)ckmc_raw_buffer->data, len);
+ DBG("ckmc_get_data [data: %s][len: %d]", text_data, len);
+
+ ckmc_buffer_free(ckmc_raw_buffer);
+
+ return text_data;
+}
+
+
+int key_manager_remove_data(const char *name)
+{
+ int ret = CKMC_ERROR_NONE;
+ ret = ckmc_remove_alias(name);
+ if (ret != CKMC_ERROR_NONE) {
+ ERR("ckmc_remove_data failed [%x]", ret);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+void key_manager_reset_data()
+{
+ key_manager_remove_data(FIRMWARE_PROPERTY_UPDATE);
+ key_manager_remove_data(FIRMWARE_PROPERTY_UPDATE_TIME);
+ key_manager_remove_data(FIRMWARE_PROPERTY_DESCRIPTION);
+ key_manager_remove_data(FIRMWARE_PROPERTY_STATE);
+ key_manager_remove_data(FIRMWARE_PROPERTY_RESULT);
+ key_manager_remove_data(FIRMWARE_PROPERTY_PROGRESS);
+
+ key_manager_remove_data(FIRMWARE_PROPERTY_NEW_VERSION);
+ key_manager_remove_data(FIRMWARE_PROPERTY_PACKAGE_URI);
+ key_manager_remove_data(FIRMWARE_PROPERTY_PACKAGE_SIZE);
+ key_manager_remove_data(FIRMWARE_PROPERTY_PACKAGE_MD5);
+}
+
+
+int platform_set_data(const char *name, char *data)
+{
+ /* TODO: how to set , platform version */
+ if (!name || !data) {
+ ERR("name or data is NULL");
+ if (name)
+ ERR("name [%s]", name);
+ if (data)
+ ERR("data [%s]", data);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+char *platform_get_data(const char *name)
+{
+ if (!name) {
+ ERR("name is NULL");
+ 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;
+
+ if (g_strcmp0(name, FIRMWARE_PROPERTY_CURRENT_VERSION) == 0) {
+ system_ret = system_info_get_platform_string("http://tizen.org/feature/platform.version", &data);
+ if (SYSTEM_INFO_ERROR_NONE != system_ret) {
+ ERR("system_info_get_platform_string() is failed[%d]", system_ret);
+ }
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_VENDER) == 0) {
+ system_ret = system_info_get_platform_string("http://tizen.org/system/manufacturer", &data);
+ if (SYSTEM_INFO_ERROR_NONE != system_ret) {
+ ERR("system_info_get_platform_string() is failed[%d]", system_ret);
+ }
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_MODEL) == 0) {
+ system_ret = system_info_get_platform_string("http://tizen.org/system/model_name", &data);
+ if (SYSTEM_INFO_ERROR_NONE != system_ret) {
+ ERR("system_info_get_platform_string() is failed[%d]", system_ret);
+ }
+ } else {
+ ERR("Invalid parameter[%s]", name);
+ }
+
+ return data;
+}
+
+
+int set_active_check(bool active_check)
+{
+ g_active_check = active_check;
+ return 0;
+}
+
+
+bool get_active_check()
+{
+ return g_active_check;
+}
+
+
+fmwup_data_s *fmwup_data_get_properties()
+{
+ FN_CALL;
+ fmwup_data_s *fmwup_get_data = NULL;
+ fmwup_get_data = (fmwup_data_s *)calloc(1, sizeof(fmwup_data_s));
+
+
+ char *temp = NULL;
+
+ temp = key_manager_get_data(FIRMWARE_PROPERTY_STATE);
+ if (temp) {
+ fmwup_get_data->state = (int64_t)atoi(temp);
+ DBG("%s:%lld", FIRMWARE_PROPERTY_STATE, fmwup_get_data->state);
+ G_FREE(temp);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_STATE);
+ }
+
+ temp = key_manager_get_data(FIRMWARE_PROPERTY_RESULT);
+ if (temp) {
+ fmwup_get_data->result = (int64_t)atoi(temp);
+ DBG("%s:%lld", FIRMWARE_PROPERTY_RESULT, fmwup_get_data->result);
+ G_FREE(temp);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_RESULT);
+ }
+
+ temp = key_manager_get_data(FIRMWARE_PROPERTY_UPDATE);
+ if (temp) {
+ fmwup_get_data->update = (int64_t)atoi(temp);
+ DBG("%s:%lld", FIRMWARE_PROPERTY_UPDATE, fmwup_get_data->update);
+ G_FREE(temp);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_UPDATE);
+ }
+
+ temp = key_manager_get_data(FIRMWARE_PROPERTY_PROGRESS);
+ if (temp) {
+ fmwup_get_data->progress = (int64_t)atoi(temp);
+ DBG("%s:%lld", FIRMWARE_PROPERTY_PROGRESS, fmwup_get_data->progress);
+ G_FREE(temp);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_PROGRESS);
+ }
+
+ fmwup_get_data->update_time = key_manager_get_data(FIRMWARE_PROPERTY_UPDATE_TIME);
+ if (fmwup_get_data->update_time) {
+ DBG("%s:%s", FIRMWARE_PROPERTY_UPDATE_TIME, fmwup_get_data->update_time);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_UPDATE_TIME);
+ }
+
+ fmwup_get_data->description = key_manager_get_data(FIRMWARE_PROPERTY_DESCRIPTION);
+ if (fmwup_get_data->description) {
+ DBG("%s:%s", FIRMWARE_PROPERTY_DESCRIPTION, fmwup_get_data->description);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_DESCRIPTION);
+ }
+
+ fmwup_get_data->new_version = key_manager_get_data(FIRMWARE_PROPERTY_NEW_VERSION);
+ if (fmwup_get_data->new_version) {
+ DBG("%s:%s", FIRMWARE_PROPERTY_NEW_VERSION, fmwup_get_data->new_version);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_NEW_VERSION);
+ }
+
+ fmwup_get_data->package_uri = key_manager_get_data(FIRMWARE_PROPERTY_PACKAGE_URI);
+ if (fmwup_get_data->package_uri) {
+ DBG("%s:%s", FIRMWARE_PROPERTY_PACKAGE_URI, fmwup_get_data->package_uri);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_PACKAGE_URI);
+ }
+
+ fmwup_get_data->package_md5 = key_manager_get_data(FIRMWARE_PROPERTY_PACKAGE_MD5);
+ if (fmwup_get_data->package_md5) {
+ DBG("%s:%s", FIRMWARE_PROPERTY_PACKAGE_MD5, fmwup_get_data->package_md5);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_PACKAGE_MD5);
+ }
+
+ temp = key_manager_get_data(FIRMWARE_PROPERTY_PACKAGE_SIZE);
+ if (temp) {
+ fmwup_get_data->package_size = (int64_t)atoi(temp);
+ DBG("%s:%lld", FIRMWARE_PROPERTY_PACKAGE_SIZE, fmwup_get_data->package_size);
+ G_FREE(temp);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_PACKAGE_SIZE);
+ }
+
+ fmwup_get_data->current_version = platform_get_data(FIRMWARE_PROPERTY_CURRENT_VERSION);
+ if (fmwup_get_data->current_version) {
+ DBG("%s:%s", FIRMWARE_PROPERTY_CURRENT_VERSION, fmwup_get_data->current_version);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_CURRENT_VERSION);
+ }
+
+ fmwup_get_data->manufacturer = platform_get_data(FIRMWARE_PROPERTY_VENDER);
+ if (fmwup_get_data->manufacturer) {
+ DBG("%s:%s", FIRMWARE_PROPERTY_VENDER, fmwup_get_data->manufacturer);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_VENDER);
+ }
+
+ fmwup_get_data->model_name = platform_get_data(FIRMWARE_PROPERTY_MODEL);
+ if (fmwup_get_data->model_name) {
+ DBG("%s:%s", FIRMWARE_PROPERTY_MODEL, fmwup_get_data->model_name);
+ } else {
+ ERR("failed to get data [%s]", FIRMWARE_PROPERTY_MODEL);
+ }
+
+ fmwup_get_data->active_check = get_active_check();
+
+ FN_END;
+ return &fmwup_get_data;
+}
+
+
+int fmwup_data_set_property(const char *name, char *data)
+{
+ if (!name) {
+ ERR("name is NULL");
+ return -1;
+ }
+
+ if (!data) {
+ ERR("data is NULL");
+ return -1;
+ }
+
+ DBG("key [%s]", name, data);
+
+ if (
+ (g_strcmp0(name, FIRMWARE_PROPERTY_UPDATE) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_UPDATE_TIME) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_DESCRIPTION) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_STATE) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_RESULT) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_PROGRESS) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_NEW_VERSION) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_URI) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_SIZE) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_MD5) == 0)
+ ) {
+ return key_manager_set_data(name, data);
+ } else if (
+ (g_strcmp0(name, FIRMWARE_PROPERTY_CURRENT_VERSION) == 0)
+// || (g_strcmp0(name, FIRMWARE_PROPERTY_VENDER) == 0) ||
+// || (g_strcmp0(name, FIRMWARE_PROPERTY_MODEL) == 0)
+ ) {
+ //TOOD: how to set current version to platform.
+ return platform_set_data(name, data);
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_ACTIVE_CHECK) == 0) {
+ if (g_strcmp0(name, "true") == 0)
+ return set_active_check(true);
+ else
+ return set_active_check(false);
+ } else {
+ ERR("Invalid key[%s]", name);
+ return -1;
+ }
+
+ return 0;
+}
+
+
+char *fmwup_data_get_property(const char *name)
+{
+ if (!name) {
+ ERR("name is NULL");
+ return NULL;
+ }
+
+ DBG("key [%s]", name);
+
+ if (
+ (g_strcmp0(name, FIRMWARE_PROPERTY_UPDATE) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_UPDATE_TIME) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_DESCRIPTION) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_STATE) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_RESULT) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_PROGRESS) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_NEW_VERSION) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_URI) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_SIZE) == 0)
+ || (g_strcmp0(name, FIRMWARE_PROPERTY_PACKAGE_MD5) == 0)
+ ) {
+ return key_manager_get_data(name);
+ } else if (
+ (g_strcmp0(name, FIRMWARE_PROPERTY_CURRENT_VERSION) == 0)
+// || (g_strcmp0(name, FIRMWARE_PROPERTY_VENDER) == 0) ||
+// || (g_strcmp0(name, FIRMWARE_PROPERTY_MODEL) == 0)
+ ) {
+ //TOOD: how to set current version to platform.
+ return platform_get_data(name);
+ } else if (g_strcmp0(name, FIRMWARE_PROPERTY_ACTIVE_CHECK) == 0) {
+ if (get_active_check() == true)
+ return g_strdup("true");
+ else
+ return g_strdup("false");
+ } else {
+ ERR("Invalid key[%s]", name);
+ return -1;
+ }
+
+ return 0;
+}
+
--- /dev/null
+/*
+ * fmwup_util_data.h
+ *
+ * Created on: Oct 17, 2017
+ * Author: hhk86heo
+ */
+
+#ifndef FMWUP_UTIL_DATA_H_
+#define FMWUP_UTIL_DATA_H_
+
+#include <stdbool.h>
+#include <glib.h>
+
+#define FIRMWARE_URI "/firmware"
+
+/* save to key manager(ckmc) with update */
+#define FIRMWARE_PROPERTY_UPDATE "update"
+#define FIRMWARE_PROPERTY_UPDATE_TIME "updatetime"
+#define FIRMWARE_PROPERTY_DESCRIPTION "description"
+#define FIRMWARE_PROPERTY_STATE "state"
+#define FIRMWARE_PROPERTY_RESULT "result"
+#define FIRMWARE_PROPERTY_PROGRESS "progress"
+
+/* save to key manager(ckmc) with pacakage */
+#define FIRMWARE_PROPERTY_NEW_VERSION "newversion"
+#define FIRMWARE_PROPERTY_PACKAGE_URI "packageuri"
+#define FIRMWARE_PROPERTY_PACKAGE_SIZE "packagesize"
+#define FIRMWARE_PROPERTY_PACKAGE_MD5 "packagemd5"
+
+/* platform information */
+#define FIRMWARE_PROPERTY_CURRENT_VERSION "version"
+#define FIRMWARE_PROPERTY_VENDER "vender"
+#define FIRMWARE_PROPERTY_MODEL "model"
+
+/* temporary value */
+#define FIRMWARE_PROPERTY_ACTIVE_CHECK "x.com.samsung.update.activecheck"
+
+#define KEY_MANAGER_MAX_DATA_LENGTH 200
+#define KEY_MANAGER_INT_DEFAULT_DATA "0"
+#define KEY_MANAGER_STR_DEFAULT_DATA ""
+#define KEY_MANAGER_BOL_DEFAULT_DATA "0"
+
+typedef struct {
+ /* Update Property */
+ int64_t state; //[R][M] fmwup_state_e - 0: Idle, 1: Downloading, 2: Downloaded, 3: Updating
+ int64_t result; //[R][M] 0: Initial, 1: Success, 2: Not enough space, 3: Out of ram, 4: Connection lost, 5: Invalid binary, 6: Invalid uri, 7: Update failed, 8: Unsupported protocol
+ int64_t update; //[RW][M] 0: Initial, 1: Download Image, 2: Upgrade Image, 3:Dwonload and Upgrade, 4 Scheduled Upgrade
+ int64_t progress; //[R][O] 0-100 range based progress include downloading state.
+ char *update_time; //[RW][O] case of (4 – update) (scheduled) TODO: ISO 8601
+ char *description; //[RW][O] Description
+
+ /* Package Information */
+ char *new_version; //[RW][M] New Version of the firmware package
+ char *package_uri; //[RW][M] Firmware package URI where the package located
+ int64_t package_size; //[RW][O] Package Size
+ char *package_md5; //[RW][O] base64-encoded 128-bit MD5 digest of the object
+
+ /* Device Information*/
+ char *manufacturer; //[R][O] Device vendor identifier
+ char *model_name; //[R][O] Device model identifier
+ char *current_version; //[R][M] Current firmware version
+
+ /* Vender specific - for polling */
+ bool active_check; //[R][O] x.com.samsung.update.activecheck
+} fmwup_data_s;
+
+//int key_manager_set_data(const char *name, char *data);
+//char *key_manager_get_data(const char *name);
+//void key_manager_reset_data();
+
+//int platform_set_data(const char *name, char *data); /* for version information */
+//char *platform_get_data(const char *name); /* vendor, model */
+
+//int set_active_check(bool active_check); /* active check */
+//bool get_active_check();
+
+fmwup_data_s *fmwup_data_get_properties();
+int fmwup_data_set_property(const char *name, char *data);
+char *fmwup_data_get_property(const char *name);
+
+#endif /* FMWUP_UTIL_DATA_H_ */
--- /dev/null
+#include <curl/curl.h>
+#include <glib.h>
+
+#include "fmwup_util_log.h"
+#include "fmwup_util_http.h"
+
+static size_t _gather_data(void *downloaded_data,
+ size_t size,
+ size_t nmemb,
+ void *user_data)
+{
+ size_t total_size = size * nmemb;
+ g_byte_array_append((GByteArray *)user_data, (const unsigned char *) downloaded_data, total_size);
+ return total_size;
+}
+
+
+void _curl_set_response(CURL *curl,
+ GByteArray *response_header,
+ GByteArray *response_body,
+ char **res_header,
+ char **res_body,
+ void *user_data)
+{
+ FN_CALL;
+ CURLcode curl_ret_code = CURLE_OK;
+
+ long response = 0;
+ curl_ret_code = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response);
+ if (CURLE_OK != curl_ret_code) {
+ ERR("curl_easy_perform(): [%s][%d]", curl_easy_strerror(curl_ret_code), curl_ret_code);
+ return;
+ }
+
+ char *tmp_header = g_strndup((const gchar *)response_header->data, response_header->len);
+ char *tmp_body = g_strndup((const gchar *)response_body->data, response_body->len);
+
+ *res_header = tmp_header;
+ *res_body = tmp_body;
+ FN_END;
+}
+
+
+void _curl_set_common_option(CURL *curl,
+ const char *url,
+ GByteArray **response_header_ptr,
+ GByteArray **response_body_ptr)
+{
+ //LOG("_curl_set_common_option()");
+ CURLcode curl_ret_code;
+
+ //LOG("set URL = [%s]", url);
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_URL, url);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_URL failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ GByteArray *response_header_data = g_byte_array_new();
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, _gather_data);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_HEADERFUNCTION failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_HEADERDATA, response_header_data);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_HEADERDATA failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ GByteArray *response_body_data = g_byte_array_new();
+
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, _gather_data);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_WRITEFUNCTION failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_WRITEDATA, response_body_data);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_WRITEDATA failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_NOPROGRESS failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ *response_header_ptr = response_header_data;
+ *response_body_ptr = response_body_data;
+
+#if 0
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_VERBOSE failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, FALSE);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_SSL_VERIFYPEER failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, FALSE);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_SSL_VERIFYHOST failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+
+ curl_ret_code = curl_easy_setopt(curl, CURLOPT_CERTINFO, 0L);
+ if (CURLE_OK != curl_ret_code) {
+ //LOG("curl_easy_setopt: CURLOPT_CERTINFO failed!! curl_ret_code[%d]", curl_ret_code);
+ }
+#endif
+}
+
+
+static void _curl_set_request_headers(CURL *curl)
+{
+ struct curl_slist *header = NULL;
+
+ char *tmp_header = NULL;
+
+ tmp_header = g_strconcat("Content-Type: ", "application/json", NULL);
+ //LOG("header=[%s]", tmp_header);
+ header = curl_slist_append(header, tmp_header);
+ g_free(tmp_header);
+
+ curl_easy_setopt(curl, CURLOPT_HTTPHEADER, header);
+}
+
+
+int fmwup_http_send_request(fmwup_http_req_e type, char *req_url, char **res_header, char **res_body)
+{
+ FN_CALL;
+
+ CURL *curl;
+ GByteArray *response_header = NULL;
+ GByteArray *response_body= NULL;
+ CURLcode error_code;
+ int ret = 0;
+
+ // Start a libcurl easy session
+ curl = curl_easy_init();
+
+ //LOG("curl_easy_init()");
+
+ _curl_set_request_headers(curl);
+
+ if (type == FMWUP_HTTP_GET) {
+ curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);
+ } else if (type == FMWUP_HTTP_POST) {
+ curl_easy_setopt(curl, CURLOPT_HTTPPOST, 1);
+ } else {
+ return -1;
+ }
+
+ _curl_set_common_option(curl, (const char *)req_url, &response_header, &response_body);
+
+ //LOG("Start curl_easy_perform......");
+ error_code = curl_easy_perform(curl);
+ INFO("curl_easy_perform(): [%s][%d]", curl_easy_strerror(error_code), error_code);
+
+ if (error_code == CURLE_ABORTED_BY_CALLBACK) {
+ ret = -1;
+ goto _END_OF_FUNC_;
+ } else if (error_code != CURLE_OK) {
+ ret = -1;
+ goto _END_OF_FUNC_;
+ }
+
+ _curl_set_response(curl, response_header, response_body, res_header, res_body, NULL);
+
+_END_OF_FUNC_:
+
+ if (response_header) {
+ g_byte_array_free(response_header, TRUE);
+ }
+ if (response_body) {
+ g_byte_array_free(response_body, TRUE);
+ }
+
+ curl_easy_cleanup(curl);
+ FN_END;
+ return ret;
+}
+
+
+int fmwup_http_download_file(const char *download_url, const char *download_path)
+{
+ FN_CALL;
+
+ if (!download_url || !download_path) {
+ ERR("Invalid parameter");
+ return -1;
+ }
+
+ int ret = 0;
+ CURL *curl;
+ FILE *fp;
+ CURLcode error_code;
+
+ curl = curl_easy_init();
+ if (curl)
+ {
+ fp = fopen(download_path, "wb");
+ curl_easy_setopt(curl, CURLOPT_URL, download_url);
+ curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, NULL);
+ curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
+ error_code = curl_easy_perform(curl);
+ INFO("curl_easy_perform() [%s][%d]", curl_easy_strerror(error_code), error_code);
+ curl_easy_cleanup(curl);
+ fclose(fp);
+
+ if (error_code != CURLE_OK) {
+ remove(download_path);
+ ret = -1;
+ }
+ } else {
+ ret = -1;
+ }
+
+ FN_END;
+ return ret;
+}
--- /dev/null
+/*
+ * fmwup_util_http.h
+ *
+ * Created on: Oct 13, 2017
+ * Author: hhk86heo
+ */
+
+#ifndef FMWUP_UTIL_HTTP_H_
+#define FMWUP_UTIL_HTTP_H_
+
+
+typedef enum {
+ FMWUP_HTTP_GET = 0,
+ FMWUP_HTTP_POST,
+ FMWUP_HTTP_PUT,
+ FMWUP_HTTP_DELETE
+}fmwup_http_req_e;
+
+int fmwup_http_send_request(fmwup_http_req_e type, char *req_url, char **res_header, char **res_body);
+
+int fmwup_http_download_file(const char *download_url, const char *download_path);
+
+#endif /* FMWUP_UTIL_HTTP_H_ */
--- /dev/null
+/*
+ * fmwup_util_data.c
+ *
+ * Created on: Oct 13, 2017
+ * Author: hhk86heo
+ */
+
+#include "fmwup_util_internal.h"
+
+#include <glib.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "fmwup_util_log.h"
+#include "fmwup_util_http.h"
+#include "fmwup_util_data.h"
+
+#define UPDATE_FILE "/opt/usr/data/fota/tota_init"
+#define FIRMWARE_FILE_NAME "fmwup.zip"
+
+extern char *g_download_path;
+extern fmwup_state_changed_cb g_state_changed_cb;
+
+int _fmwup_propagate_firmware_resource(void)
+{
+ int ret = 0;
+ ret = st_things_notify_observers(FIRMWARE_URI);
+ if (0 == ret) {
+ ERR("Failed st_things_notify_observers [%d]", ret);
+ }
+ return ret;
+}
+
+void fmwup_propagate_firmware_status_resource(fmwup_state_e state, fmwup_result_e result)
+{
+ DBG("Propagate state[%d], result[%d]", state, result);
+
+ int ret = 0;
+
+ char temp_data[KEY_MANAGER_MAX_DATA_LENGTH] = {0,};
+
+ 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);
+ }
+
+ 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);
+// }
+ }
+}
+
+static void _exec_update()
+{
+ FILE* fp = fopen(UPDATE_FILE, "w");
+ if(!fp) {
+ ERR("fopen error: %d", errno);
+ return;
+ }
+ fclose(fp);
+}
+
+
+bool _parse_secure_url(char *json, char **url_value)
+{
+ if (!json && *json != '{' && *(json+1) != '\"') {
+
+ return false;
+ }
+
+ char *ret_str;
+ ret_str = strtok(json,"{\"");
+
+ if (ret_str == NULL && g_strcmp0(ret_str, "url") != 0) {
+ ERR("Invalid json [url]");
+ return false;
+ }
+
+ ret_str = strtok(NULL,"\"");
+ if (ret_str == NULL && g_strcmp0(ret_str, ":") != 0) {
+ ERR("Invalid delimeter [:]");
+ return false;
+ }
+
+ ret_str = strtok(NULL,"\"");
+ if (ret_str == NULL)
+ return false;
+
+ *url_value = g_strdup(ret_str);
+
+ return true;
+}
+
+void _fmwup_handle_update_command(int64_t update_type)
+{
+ int result = FMWUP_RESULT_INIT;
+#ifdef _USE_WWST_
+ char *res_header = NULL;
+ char *res_body = NULL;
+ char *request_uri = NULL;
+ char *sec_download_url = NULL;
+ char *download_path = NULL;
+#endif
+
+ char *package_uri = fmwup_data_get_property(FIRMWARE_PROPERTY_PACKAGE_URI);
+ char *new_version = fmwup_data_get_property(FIRMWARE_PROPERTY_NEW_VERSION);
+ char *current_version = fmwup_data_get_property(FIRMWARE_PROPERTY_CURRENT_VERSION);
+ char *temp_state = fmwup_data_get_property(FIRMWARE_PROPERTY_STATE);
+ int state = 0;
+
+ if (!package_uri || !new_version || !current_version || !temp_state) {
+ ERR("failed get property");
+ result = FMWUP_RESULT_UPDATE_FAILED;
+ goto _END_OF_FUNC_;
+ }
+
+ state = atoi(temp_state);
+ if (g_strcmp0(package_uri, "") == 0 ||
+ g_strcmp0(new_version, "") == 0 ||
+ g_strcmp0(current_version, new_version) == 0)
+ {
+ ERR("Invalid value, package_uri[%s], new_version[%s], current_version[%s]",
+ package_uri, new_version, current_version);
+ result = FMWUP_RESULT_UPDATE_FAILED;
+ goto _END_OF_FUNC_;
+ }
+
+ 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);
+
+#ifdef _USE_WWST_
+
+ request_uri = g_strconcat(package_uri, NULL);
+ download_path = g_strconcat(g_download_path, FIRMWARE_FILE_NAME, NULL);
+
+ INFO("request_uri[%s]", request_uri);
+
+ if (fmwup_http_send_request(FMWUP_HTTP_GET, request_uri, &res_header, &res_body) != 0) {
+ ERR("cannot get Secure URL");
+ result = FMWUP_RESULT_INVALID_URI;
+ goto _END_OF_FUNC_;
+ } else {
+ //parsing
+ INFO("res_header[%s] res_body[%s]",res_header, res_body);
+
+ if (_parse_secure_url(res_body, &sec_download_url)) {
+ INFO("download url[%s] download path[%s]",sec_download_url, download_path);
+
+ if (fmwup_http_download_file(sec_download_url, (const char *)download_path) != 0) {
+ ERR("fmwup_http_download_file failed");
+ result = FMWUP_RESULT_INVALID_URI;
+ goto _END_OF_FUNC_;
+ }
+
+ } else {
+ ERR("_parse_secure_url failed");
+ result = FMWUP_RESULT_INVALID_URI;
+ goto _END_OF_FUNC_;
+ }
+ }
+
+#else
+ if (fmwup_http_download_file(package_uri, (const char *)g_download_path) != 0) {
+ ERR("fmwup_http_download_file failed");
+ result = FMWUP_RESULT_INVALID_URI;
+ goto _END_OF_FUNC_;
+ }
+#endif
+
+ DBG("*** Firmware image downloaded ***");
+ fmwup_propagate_firmware_status_resource(FMWUP_STATE_DOWNLOADED, FMWUP_RESULT_INIT);
+ }
+
+ 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);
+
+ //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);
+ }
+
+#ifdef _USE_WWST_
+ G_FREE(res_header);
+ G_FREE(res_body);
+ G_FREE(download_path);
+ G_FREE(sec_download_url);
+ G_FREE(request_uri);
+#endif
+
+ return;
+}
+
+void *_fmwup_worker(void *data)
+{
+ int64_t exec_type = *(int64_t *)data;
+ _fmwup_handle_update_command(exec_type);
+ G_FREE(data);
+
+ return NULL;
+}
+
+
+int fmwup_internal_update_command(int64_t update_type)
+{
+ int64_t *update = (int64_t *)calloc(1, sizeof(int64_t));
+ if (!update) {
+ ERR("Memory allocation error!");
+ return FMWUP_ERROR_MEMORY_ERR;
+ }
+
+ *update = update_type;
+
+ pthread_t pThread;
+ pthread_create(&pThread, NULL, _fmwup_worker, update);
+
+ return FMWUP_ERROR_NONE;
+}
+
--- /dev/null
+/*
+ * fmwup_util_data.h
+ *
+ * Created on: Oct 13, 2017
+ * Author: hhk86heo
+ */
+
+#ifndef FMWUP_UTIL_INTERNAL_H_
+#define FMWUP_UTIL_INTERNAL_H_
+
+#include <glib.h>
+
+#include "fmwup_api.h"
+
+void fmwup_propagate_firmware_status_resource(fmwup_state_e state, fmwup_result_e result);
+int fmwup_internal_update_command(int64_t update_type);
+
+#endif /* FMWUP_UTIL_INTERNAL_H_ */
--- /dev/null
+/*
+ * fmwup_log.h
+ *
+ * Created on: Oct 11, 2017
+ * Author: hhk86heo
+ */
+
+#ifndef FMWUP_UTIL_LOG_H_
+#define FMWUP_UTIL_LOG_H_
+
+#include <dlog.h>
+#include <glib.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "FMWUP-THINGS-SDK-API"
+
+#ifndef __MODULE__
+#define __MODULE__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
+#endif
+
+#define ERR(fmt, args...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d): "fmt"\n", __MODULE__, __func__, __LINE__, ##args)
+#define WARN(fmt, args...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d): "fmt"\n", __MODULE__, __func__, __LINE__,##args)
+#define INFO(fmt, args...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d): "fmt"\n", __MODULE__, __func__, __LINE__,##args)
+#define DBG(fmt, args...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d): "fmt"\n", __MODULE__, __func__, __LINE__,##args)
+
+#define FN_CALL DBG("BEGIN")
+#define FN_END DBG("END")
+
+#define G_FREE(p) do { if (p) { g_free(p); p = NULL; } } while (0);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+#endif /* FMWUP_UTIL_LOG_H_ */
projects / platform / core / service / cloud / ua-client.git / commitdiff