From: youngman Date: Tue, 28 Jun 2016 00:10:50 +0000 (+0900) Subject: check init X-Git-Tag: submit/tizen/20160628.100126~3 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d155d044422a1514db422966788aee54bae0540e;p=platform%2Fcore%2Fiot%2Fiotcon.git check init Change-Id: Ie021c2967e5d79aa868ea022fda9e43f04dabf87 Signed-off-by: youngman --- diff --git a/lib/icl-ioty-ocprocess.c b/lib/icl-ioty-ocprocess.c index 3d2d99b..67a571d 100644 --- a/lib/icl-ioty-ocprocess.c +++ b/lib/icl-ioty-ocprocess.c @@ -94,7 +94,6 @@ void* icl_ioty_ocprocess_thread(void *data) { FN_CALL; int ret; - OCStackResult result; // TODO: Current '100ms' is not proven sleep time. Revise the time after test. // TODO: Or recommend changes to event driven architecture @@ -108,10 +107,10 @@ void* icl_ioty_ocprocess_thread(void *data) ic_utils_mutex_lock(IC_UTILS_MUTEX_POLLING); while (icl_ioty_alive) { ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCProcess(); + ret = OCProcess(); ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCProcess() Fail(%d)", result); + if (OC_STACK_OK != ret) { + ERR("OCProcess() Fail(%d)", ret); break; } @@ -125,7 +124,7 @@ void* icl_ioty_ocprocess_thread(void *data) static gboolean _icl_ioty_ocprocess_find_idle_cb(gpointer p) { - int i; + int i, ret; icl_cb_s *cb_data; icl_find_cb_s *find_cb_data = p; iotcon_found_resource_cb cb; @@ -142,9 +141,14 @@ static gboolean _icl_ioty_ocprocess_find_idle_cb(gpointer p) INFO("Stop the callback"); cb_data->cb = NULL; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return G_SOURCE_REMOVE; + } + OCCancel(cb_data->handle, OC_LOW_QOS, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); break; } @@ -223,6 +227,7 @@ OCStackApplicationResult icl_ioty_ocprocess_find_cb(void *ctx, OCDoHandle handle static gboolean _icl_ioty_ocprocess_device_info_idle_cb(gpointer p) { + int ret; icl_cb_s *cb_data; icl_device_cb_s *device_cb_data = p; iotcon_device_info_cb cb; @@ -236,9 +241,14 @@ static gboolean _icl_ioty_ocprocess_device_info_idle_cb(gpointer p) cb_data->user_data)) { /* Stop */ cb_data->cb = NULL; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return G_SOURCE_REMOVE; + } + OCCancel(cb_data->handle, OC_LOW_QOS, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); } } @@ -292,6 +302,7 @@ OCStackApplicationResult icl_ioty_ocprocess_device_info_cb(void *ctx, static gboolean _icl_ioty_ocprocess_platform_info_idle_cb(gpointer p) { + int ret; icl_cb_s *cb_data; icl_platform_cb_s *platform_cb_data = p; iotcon_platform_info_cb cb; @@ -305,9 +316,14 @@ static gboolean _icl_ioty_ocprocess_platform_info_idle_cb(gpointer p) cb_data->user_data)) { /* Stop */ cb_data->cb = NULL; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return G_SOURCE_REMOVE; + } + OCCancel(cb_data->handle, OC_LOW_QOS, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); } } diff --git a/lib/icl-ioty.c b/lib/icl-ioty.c index 8bbfb37..5105ea2 100644 --- a/lib/icl-ioty.c +++ b/lib/icl-ioty.c @@ -48,6 +48,7 @@ #include "icl-ioty.h" #include "icl-cbor.h" +static bool icl_state; static int icl_remote_resource_time_interval = IC_REMOTE_RESOURCE_DEFAULT_TIME_INTERVAL; static GHashTable *icl_monitoring_table; static GHashTable *icl_caching_table; @@ -59,7 +60,6 @@ void icl_ioty_deinit(pthread_t thread) { FN_CALL; int ret; - OCStackResult result; icl_ioty_ocprocess_stop(); ic_utils_cond_signal(IC_UTILS_COND_POLLING); @@ -72,9 +72,15 @@ void icl_ioty_deinit(pthread_t thread) ic_utils_cond_polling_destroy(); - result = OCStop(); - if (OC_STACK_OK != result) - ERR("OCStop() Fail(%d)", result); + ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = OCStop(); + if (OC_STACK_OK != ret) { + ERR("OCStop() Fail(%d)", ret); + ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + return; + } + icl_state = false; + ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); } static FILE* _icl_ioty_ps_fopen(const char *path, const char *mode) @@ -86,7 +92,6 @@ int icl_ioty_set_persistent_storage(const char *file_path, bool is_pt) { FN_CALL; int ret; - OCStackResult result; RETV_IF(NULL == file_path, IOTCON_ERROR_INVALID_PARAMETER); @@ -118,11 +123,15 @@ int icl_ioty_set_persistent_storage(const char *file_path, bool is_pt) icl_ioty_ps.close = fclose; icl_ioty_ps.unlink = unlink; - result = OCRegisterPersistentStorageHandler(&icl_ioty_ps); - if (OC_STACK_OK != result) { - ERR("OCRegisterPersistentStorageHandler() Fail(%d)", result); + ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = OCRegisterPersistentStorageHandler(&icl_ioty_ps); + if (OC_STACK_OK != ret) { + ERR("OCRegisterPersistentStorageHandler() Fail(%d)", ret); + ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); return IOTCON_ERROR_IOTIVITY; } + icl_state = true; + ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); return IOTCON_ERROR_NONE; } @@ -143,19 +152,37 @@ int icl_ioty_set_generate_pin_cb() return IOTCON_ERROR_NONE; } +int icl_ioty_mutex_lock() +{ + ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + + if (false == icl_state) { + ERR("IoTCon is not initialized"); + ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + return IOTCON_ERROR_IOTIVITY; + } + + return IOTCON_ERROR_NONE; +} + int icl_ioty_init(pthread_t *out_thread) { FN_CALL; int ret; pthread_attr_t attr; - OCStackResult result; RETV_IF(NULL == out_thread, IOTCON_ERROR_INVALID_PARAMETER); - result = OCInit(NULL, 0, OC_CLIENT_SERVER); - if (OC_STACK_OK != result) { - ERR("OCInit() Fail(%d)", result); - return ic_ioty_parse_oic_error(result); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } + ret = OCInit(NULL, 0, OC_CLIENT_SERVER); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCInit() Fail(%d)", ret); + return ic_ioty_parse_oic_error(ret); } // TODO: temp code @@ -216,9 +243,13 @@ static gboolean _icl_ioty_timeout(gpointer user_data) } } - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCCancel(cb_info->handle, OC_LOW_QOS, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCCancel() Fail(%d)", ret); @@ -255,12 +286,11 @@ int icl_ioty_find_resource(const char *host_address, void *user_data) { FN_CALL; - int len, timeout; + int ret, len, timeout; char *coap_str; char uri[PATH_MAX] = {0}; icl_cb_s *cb_data; OCDoHandle handle; - OCStackResult result; OCCallbackData cbdata = {0}; OCConnectivityType oic_conn_type; @@ -297,17 +327,23 @@ int icl_ioty_find_resource(const char *host_address, oic_conn_type = ic_ioty_convert_connectivity_type(connectivity_type); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _icl_ioty_free_cb_data(cb_data); + return ret; + } + // TODO: QoS is come from lib. - result = OCDoResource(&handle, OC_REST_DISCOVER, uri, NULL, NULL, oic_conn_type, + ret = OCDoResource(&handle, OC_REST_DISCOVER, uri, NULL, NULL, oic_conn_type, OC_LOW_QOS, &cbdata, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); cb_data->handle = handle; - if (OC_STACK_OK != result) { - ERR("OCDoResource(DISCOVER) Fail(%d)", result); + if (OC_STACK_OK != ret) { + ERR("OCDoResource(DISCOVER) Fail(%d)", ret); _icl_ioty_free_cb_data(cb_data); - return ic_ioty_parse_oic_error(result); + return ic_ioty_parse_oic_error(ret); } iotcon_get_timeout(&timeout); @@ -321,11 +357,10 @@ int icl_ioty_find_device_info(const char *host_address, iotcon_device_info_cb cb, void *user_data) { - int timeout; + int ret, timeout; char uri[PATH_MAX] = {0}; icl_cb_s *cb_data = NULL; OCDoHandle handle; - OCStackResult result; OCCallbackData cbdata = {0}; OCConnectivityType oic_conn_type; @@ -351,17 +386,22 @@ int icl_ioty_find_device_info(const char *host_address, oic_conn_type = ic_ioty_convert_connectivity_type(connectivity_type); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _icl_ioty_free_cb_data(cb_data); + return ret; + } // TODO: QoS is come from lib. And user can set QoS to client structure. - result = OCDoResource(&handle, OC_REST_DISCOVER, uri, NULL, NULL, oic_conn_type, + ret = OCDoResource(&handle, OC_REST_DISCOVER, uri, NULL, NULL, oic_conn_type, OC_LOW_QOS, &cbdata, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); cb_data->handle = handle; - if (OC_STACK_OK != result) { - ERR("OCDoResource(DISCOVER) Fail(%d)", result); + if (OC_STACK_OK != ret) { + ERR("OCDoResource(DISCOVER) Fail(%d)", ret); _icl_ioty_free_cb_data(cb_data); - return ic_ioty_parse_oic_error(result); + return ic_ioty_parse_oic_error(ret); } iotcon_get_timeout(&timeout); @@ -375,11 +415,10 @@ int icl_ioty_find_platform_info(const char *host_address, iotcon_platform_info_cb cb, void *user_data) { - int timeout; + int ret, timeout; char uri[PATH_MAX] = {0}; icl_cb_s *cb_data = NULL; OCDoHandle handle; - OCStackResult result; OCCallbackData cbdata = {0}; OCConnectivityType oic_conn_type; @@ -405,17 +444,22 @@ int icl_ioty_find_platform_info(const char *host_address, oic_conn_type = ic_ioty_convert_connectivity_type(connectivity_type); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _icl_ioty_free_cb_data(cb_data); + return ret; + } // TODO: QoS is come from lib. And user can set QoS to client structure. - result = OCDoResource(&handle, OC_REST_DISCOVER, uri, NULL, NULL, oic_conn_type, + ret = OCDoResource(&handle, OC_REST_DISCOVER, uri, NULL, NULL, oic_conn_type, OC_LOW_QOS, &cbdata, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); cb_data->handle = handle; - if (OC_STACK_OK != result) { - ERR("OCDoResource(DISCOVER) Fail(%d)", result); + if (OC_STACK_OK != ret) { + ERR("OCDoResource(DISCOVER) Fail(%d)", ret); _icl_ioty_free_cb_data(cb_data); - return ic_ioty_parse_oic_error(result); + return ic_ioty_parse_oic_error(ret); } iotcon_get_timeout(&timeout); @@ -437,9 +481,14 @@ int icl_ioty_set_device_info(const char *device_name) return IOTCON_ERROR_OUT_OF_MEMORY; } - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + free(device_info.deviceName); + return ret; + } ret = OCSetDeviceInfo(device_info); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCSetDeviceInfo() Fail(%d)", ret); @@ -462,9 +511,14 @@ int icl_ioty_set_platform_info() return ret; } - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + ic_utils_free_platform_info(&platform_info); + return ret; + } ret = OCSetPlatformInfo(platform_info); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCSetPlatformInfo() Fail(%d)", ret); @@ -483,9 +537,9 @@ int icl_ioty_add_presence_cb(const char *host_address, void *user_data, iotcon_presence_h *presence_handle) { + int ret; OCDoHandle handle; const char *address; - OCStackResult result; char uri[PATH_MAX] = {0}; OCCallbackData cbdata = {0}; OCConnectivityType oic_conn_type; @@ -520,14 +574,19 @@ int icl_ioty_add_presence_cb(const char *host_address, oic_conn_type = ic_ioty_convert_connectivity_type(connectivity_type); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCDoResource(&handle, OC_REST_PRESENCE, uri, NULL, NULL, oic_conn_type, + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + icl_destroy_presence(presence); + return ret; + } + ret = OCDoResource(&handle, OC_REST_PRESENCE, uri, NULL, NULL, oic_conn_type, OC_LOW_QOS, &cbdata, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); presence->handle = handle; - if (OC_STACK_OK != result) { - ERR("OCDoResource(PRESENCE) Fail(%d)", result); + if (OC_STACK_OK != ret) { + ERR("OCDoResource(PRESENCE) Fail(%d)", ret); icl_destroy_presence(presence); return IOTCON_ERROR_IOTIVITY; } @@ -543,9 +602,13 @@ int icl_ioty_remove_presence_cb(iotcon_presence_h presence) RETV_IF(NULL == presence, IOTCON_ERROR_INVALID_PARAMETER); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCCancel(presence->handle, OC_LOW_QOS, NULL, 0); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCCancel() Fail(%d)", ret); @@ -690,11 +753,17 @@ static int _icl_ioty_remote_resource_observe(iotcon_remote_resource_h resource, cbdata.cb = icl_ioty_ocprocess_observe_cb; cbdata.cd = _icl_ioty_free_observe_container; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _icl_ioty_free_observe_container(cb_container); + free(uri); + return ret; + } // TODO: QoS is come from lib. And user can set QoS to client structure. ret = OCDoResource(&handle, method, uri, &dev_addr, NULL, oic_conn_type, OC_HIGH_QOS, &cbdata, oic_options_ptr, options_size); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCDoResource(OBSERVE:%d) Fail(%d)", method, ret); @@ -758,9 +827,13 @@ int icl_ioty_remote_resource_observe_cancel(iotcon_remote_resource_h resource, } handle = IC_INT64_TO_POINTER(observe_handle); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCCancel(handle, OC_HIGH_QOS, oic_options_ptr, options_size); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCCancel() Fail(%d)", ret); @@ -914,10 +987,15 @@ static int _icl_ioty_remote_resource_crud( cbdata.cb = icl_ioty_ocprocess_crud_cb; cbdata.cd = _icl_ioty_free_response_container; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _icl_ioty_free_response_container(cb_container); + return ret; + } ret = OCDoResource(NULL, method, uri, &dev_addr, payload, oic_conn_type, OC_HIGH_QOS, &cbdata, oic_options_ptr, options_size); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCDoResource(CRUD:%d) Fail(%d)", method, ret); @@ -1347,9 +1425,13 @@ int icl_ioty_start_presence(unsigned int time_to_live) RETV_IF(IC_PRESENCE_TTL_SECONDS_MAX < time_to_live, IOTCON_ERROR_INVALID_PARAMETER); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCStartPresence(time_to_live); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCStartPresence() Fail(%d)", ret); @@ -1363,9 +1445,13 @@ int icl_ioty_stop_presence() { int ret; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCStopPresence(); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCStopPresence() Fail(%d)", ret); return ic_ioty_parse_oic_error(ret); @@ -1377,11 +1463,15 @@ int icl_ioty_stop_presence() static int _icl_ioty_resource_bind_type(OCResourceHandle handle, const char *resource_type) { - OCStackResult ret; + int ret; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCBindResourceTypeToResource(handle, resource_type); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCBindResourceTypeToResource() Fail(%d)", ret); @@ -1394,15 +1484,19 @@ static int _icl_ioty_resource_bind_type(OCResourceHandle handle, static int _icl_ioty_resource_bind_interface(OCResourceHandle handle, const char *iface) { - OCStackResult result; + int ret; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCBindResourceInterfaceToResource(handle, iface); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } + ret = OCBindResourceInterfaceToResource(handle, iface); + icl_ioty_mutex_unlock(); - if (OC_STACK_OK != result) { - ERR("OCBindResourceInterfaceToResource() Fail(%d)", result); - return ic_ioty_parse_oic_error(result); + if (OC_STACK_OK != ret) { + ERR("OCBindResourceInterfaceToResource() Fail(%d)", ret); + return ic_ioty_parse_oic_error(ret); } return IOTCON_ERROR_NONE; @@ -1445,10 +1539,14 @@ int icl_ioty_resource_create(const char *uri_path, policies = ic_ioty_convert_policies(policies); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCCreateResource(&handle, res_types->type_list->data, ifaces->iface_list->data, uri_path, icl_ioty_ocprocess_request_cb, resource, policies); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCCreateResource() Fail(%d)", ret); iotcon_resource_destroy(resource); @@ -1540,7 +1638,7 @@ int icl_ioty_resource_bind_child_resource(iotcon_resource_h parent, iotcon_resource_h child) { FN_CALL; - OCStackResult ret; + int ret; OCResourceHandle handle_parent, handle_child; RETV_IF(NULL == parent, IOTCON_ERROR_INVALID_PARAMETER); @@ -1550,9 +1648,13 @@ int icl_ioty_resource_bind_child_resource(iotcon_resource_h parent, handle_parent = IC_INT64_TO_POINTER(parent->handle); handle_child = IC_INT64_TO_POINTER(child->handle); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCBindResource(handle_parent, handle_child); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCBindResource() Fail(%d)", ret); @@ -1566,7 +1668,7 @@ int icl_ioty_resource_unbind_child_resource(iotcon_resource_h parent, iotcon_resource_h child) { FN_CALL; - OCStackResult ret; + int ret; OCResourceHandle handle_parent, handle_child; RETV_IF(NULL == parent, IOTCON_ERROR_INVALID_PARAMETER); @@ -1575,9 +1677,13 @@ int icl_ioty_resource_unbind_child_resource(iotcon_resource_h parent, handle_parent = IC_INT64_TO_POINTER(parent->handle); handle_child = IC_INT64_TO_POINTER(child->handle); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCUnBindResource(handle_parent, handle_child); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCUnBindResource() Fail(%d)", ret); @@ -1624,12 +1730,16 @@ int icl_ioty_resource_notify(iotcon_resource_h resource, iotcon_representation_h handle = IC_INT64_TO_POINTER(resource->handle); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } if (payload) ret = OCNotifyListOfObservers(handle, obs_ids, obs_length, payload, oc_qos); else ret = OCNotifyAllObservers(handle, oc_qos); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_NO_OBSERVERS == ret) { WARN("No Observers. Stop Notifying"); @@ -1652,9 +1762,13 @@ int icl_ioty_resource_destroy(iotcon_resource_h resource) handle = IC_INT64_TO_POINTER(resource->handle); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCDeleteResource(handle); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCDeleteResource() Fail(%d)", ret); @@ -1704,10 +1818,15 @@ int icl_ioty_lite_resource_create(const char *uri_path, policies = ic_ioty_convert_policies(policies); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + icl_ioty_lite_resource_destroy(resource); + return ret; + } ret = OCCreateResource(&handle, res_types->type_list->data, res_iface, uri_path, icl_ioty_ocprocess_lite_request_cb, resource, policies); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCCreateResource() Fail(%d)", ret); icl_ioty_lite_resource_destroy(resource); @@ -1736,9 +1855,13 @@ int icl_ioty_lite_resource_destroy(iotcon_lite_resource_h resource) handle = IC_INT64_TO_POINTER(resource->handle); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCDeleteResource(handle); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCDeleteResource() Fail(%d)", ret); @@ -1761,9 +1884,13 @@ int icl_ioty_lite_resource_notify(iotcon_lite_resource_h resource) handle = IC_INT64_TO_POINTER(resource->handle); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCNotifyAllObservers(handle, IOTCON_QOS_HIGH); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_NO_OBSERVERS == ret) { WARN("No Observers. Stop Notifying"); @@ -1827,9 +1954,13 @@ int icl_ioty_response_send(iotcon_response_h response_handle) /* related to block transfer */ response.persistentBufferFlag = 0; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } ret = OCDoResponse(&response); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + icl_ioty_mutex_unlock(); if (OC_STACK_OK != ret) { ERR("OCDoResponse() Fail(%d)", ret); diff --git a/lib/icl-ioty.h b/lib/icl-ioty.h index e93494d..f58a916 100644 --- a/lib/icl-ioty.h +++ b/lib/icl-ioty.h @@ -22,6 +22,7 @@ #include "iotcon-client.h" #include "iotcon-types.h" +#include "ic-utils.h" typedef enum { ICL_FIND_RESOURCE, @@ -39,6 +40,8 @@ typedef struct { OCDoHandle handle; } icl_cb_s; +int icl_ioty_mutex_lock(); +static inline void icl_ioty_mutex_unlock() { return ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); } void icl_ioty_deinit(pthread_t thread); int icl_ioty_init(pthread_t *out_thread); diff --git a/lib/icl-provisioning.c b/lib/icl-provisioning.c index 50b32c5..bbf2153 100644 --- a/lib/icl-provisioning.c +++ b/lib/icl-provisioning.c @@ -149,7 +149,6 @@ API int iotcon_provisioning_initialize(const char *file_path, const char *db_pat { FN_CALL; int ret; - OCStackResult result; RETV_IF(false == ic_utils_check_ocf_feature(), IOTCON_ERROR_NOT_SUPPORTED); RETV_IF(false == ic_utils_check_permission((IC_PERMISSION_INTERNET @@ -169,17 +168,29 @@ API int iotcon_provisioning_initialize(const char *file_path, const char *db_pat else DBG("No provisioning DB File, creating new."); - result = OCInitPM(db_path); - if (OC_STACK_OK != result) { - ERR("OCInitPM() Fail(%d)", result); - return _provisioning_parse_oic_error(result); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + iotcon_deinitialize(); + return ret; + } + + ret = OCInitPM(db_path); + if (OC_STACK_OK != ret) { + ERR("OCInitPM() Fail(%d)", ret); + ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); + iotcon_deinitialize(); + return _provisioning_parse_oic_error(ret); } _provisioning_set_justworks(); - result = OCSetOwnerTransferCallbackData(OIC_JUST_WORKS, &icl_justworks_otmcb); - if (OC_STACK_OK != result) { - ERR("OCSetOwnerTransferCallbackData() Fail(%d)", result); - return _provisioning_parse_oic_error(result); + + ret = OCSetOwnerTransferCallbackData(OIC_JUST_WORKS, &icl_justworks_otmcb); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCSetOwnerTransferCallbackData() Fail(%d)", ret); + iotcon_deinitialize(); + return _provisioning_parse_oic_error(ret); } return IOTCON_ERROR_NONE; @@ -209,16 +220,24 @@ API int iotcon_provisioning_set_randompins(iotcon_provisioning_randompins_cb cb, void *user_data) { FN_CALL; - OCStackResult result; + int ret; RETV_IF(false == ic_utils_check_ocf_feature(), IOTCON_ERROR_NOT_SUPPORTED); RETV_IF(NULL == cb, IOTCON_ERROR_INVALID_PARAMETER); _provisioning_set_randompins(); - result = OCSetOwnerTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &icl_pinbased_otmcb); - if (OC_STACK_OK != result) { - ERR("OCSetOwnerTransferCallbackData() Fail(%d)", result); - return _provisioning_parse_oic_error(result); + + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return ret; + } + + ret = OCSetOwnerTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &icl_pinbased_otmcb); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCSetOwnerTransferCallbackData() Fail(%d)", ret); + return _provisioning_parse_oic_error(ret); } icl_randompins_cb_container.cb = cb; @@ -297,17 +316,21 @@ static void* _provisioning_discover_all_thread(void *user_data) { FN_CALL; int ret; - OCStackResult result; OCProvisionDev_t *owned_list = NULL; OCProvisionDev_t *unowned_list = NULL; iotcon_provisioning_devices_h temp_devices; struct icl_provisioning_discover_cb_container *container = user_data; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCGetDevInfoFromNetwork(container->timeout, &owned_list, &unowned_list); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCGetDevInfoFromNetwork() Fail(%d)", result); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return NULL; + } + + ret = OCGetDevInfoFromNetwork(container->timeout, &owned_list, &unowned_list); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCGetDevInfoFromNetwork() Fail(%d)", ret); _provisioning_discover_cb_container_destroy(container); return NULL; } @@ -366,16 +389,20 @@ static void* _provisioning_discover_unowned_thread(void *user_data) { FN_CALL; int ret; - OCStackResult result; OCProvisionDev_t *unowned_list = NULL; iotcon_provisioning_devices_h temp_devices; struct icl_provisioning_discover_cb_container *container = user_data; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCDiscoverUnownedDevices(container->timeout, &unowned_list); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCDiscoverUnownedDevices() Fail(%d)", result); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return NULL; + } + + ret = OCDiscoverUnownedDevices(container->timeout, &unowned_list); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCDiscoverUnownedDevices() Fail(%d)", ret); _provisioning_discover_cb_container_destroy(container); return NULL; } @@ -412,16 +439,20 @@ static void* _provisioning_discover_owned_thread(void *user_data) { FN_CALL; int ret; - OCStackResult result; OCProvisionDev_t *owned_list = NULL; iotcon_provisioning_devices_h temp_devices; struct icl_provisioning_discover_cb_container *container = user_data; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCDiscoverOwnedDevices(container->timeout, &owned_list); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCDiscoverOwnedDevices() Fail(%d)", result); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + return NULL; + } + + ret = OCDiscoverOwnedDevices(container->timeout, &owned_list); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCDiscoverOwnedDevices() Fail(%d)", ret); _provisioning_discover_cb_container_destroy(container); return NULL; } @@ -703,7 +734,6 @@ API int iotcon_provisioning_register_unowned_devices( { FN_CALL; int ret; - OCStackResult result; OCProvisionDev_t *dev_list; struct icl_provisioning_ownership_transfer_cb_container *container; @@ -729,13 +759,19 @@ API int iotcon_provisioning_register_unowned_devices( dev_list = icl_provisioning_devices_get_devices(container->devices); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCDoOwnershipTransfer(container, dev_list, _provisioning_ownership_transfer_cb); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCDoOwnershipTransfer() Fail(%d)", result); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); _provisioning_ownership_transfer_cb_container_destroy(container); - return _provisioning_parse_oic_error(result); + return ret; + } + + ret = OCDoOwnershipTransfer(container, dev_list, _provisioning_ownership_transfer_cb); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCDoOwnershipTransfer() Fail(%d)", ret); + _provisioning_ownership_transfer_cb_container_destroy(container); + return _provisioning_parse_oic_error(ret); } return IOTCON_ERROR_NONE; @@ -749,7 +785,6 @@ API int iotcon_provisioning_register_unowned_device( { FN_CALL; int ret; - OCStackResult result; OCProvisionDev_t *dev_list, *cloned_list; struct icl_provisioning_ownership_transfer_cb_container *container; @@ -775,13 +810,19 @@ API int iotcon_provisioning_register_unowned_device( return ret; } - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCDoOwnershipTransfer(container, cloned_list, _provisioning_ownership_transfer_cb); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCDoOwnershipTransfer() Fail(%d)", result); + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); _provisioning_ownership_transfer_cb_container_destroy(container); - return _provisioning_parse_oic_error(result); + return ret; + } + + ret = OCDoOwnershipTransfer(container, cloned_list, _provisioning_ownership_transfer_cb); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCDoOwnershipTransfer() Fail(%d)", ret); + _provisioning_ownership_transfer_cb_container_destroy(container); + return _provisioning_parse_oic_error(ret); } return IOTCON_ERROR_NONE; @@ -850,7 +891,6 @@ API int iotcon_provisioning_provision_cred(iotcon_provisioning_device_h device1, FN_CALL; int ret; size_t key_size; - OCStackResult result; struct icl_provisioning_provision_cred_cb_container *container; RETV_IF(false == ic_utils_check_ocf_feature(), IOTCON_ERROR_NOT_SUPPORTED); @@ -881,18 +921,24 @@ API int iotcon_provisioning_provision_cred(iotcon_provisioning_device_h device1, container->cb = cb; container->user_data = user_data; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCProvisionCredentials(container, + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _provisioning_provision_cred_cb_container_destroy(container); + return ret; + } + + ret = OCProvisionCredentials(container, SYMMETRIC_PAIR_WISE_KEY, key_size, icl_provisioning_device_get_device(container->device1), icl_provisioning_device_get_device(container->device2), _provisioning_provision_cred_cb); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCProvisionCredentails() Fail(%d)", result); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCProvisionCredentails() Fail(%d)", ret); _provisioning_provision_cred_cb_container_destroy(container); - return _provisioning_parse_oic_error(result); + return _provisioning_parse_oic_error(ret); } return IOTCON_ERROR_NONE; @@ -1031,7 +1077,6 @@ API int iotcon_provisioning_provision_acl(iotcon_provisioning_device_h device, FN_CALL; int ret; OicSecAcl_t *oic_acl; - OCStackResult result; struct icl_provisioning_provision_acl_cb_container *container; RETV_IF(false == ic_utils_check_ocf_feature(), IOTCON_ERROR_NOT_SUPPORTED); @@ -1064,16 +1109,22 @@ API int iotcon_provisioning_provision_acl(iotcon_provisioning_device_h device, oic_acl = _provisioning_convert_acl(device, acl); - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCProvisionACL(container, + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _provisioning_provision_acl_cb_container_destroy(container); + return ret; + } + + ret = OCProvisionACL(container, icl_provisioning_device_get_device(container->device), oic_acl, _provisioning_provision_acl_cb); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCProvisionACL() Fail(%d)", result); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCProvisionACL() Fail(%d)", ret); _provisioning_provision_acl_cb_container_destroy(container); - return _provisioning_parse_oic_error(result); + return _provisioning_parse_oic_error(ret); } return IOTCON_ERROR_NONE; @@ -1153,7 +1204,6 @@ API int iotcon_provisioning_pairwise_devices(iotcon_provisioning_device_h device FN_CALL; int ret; size_t key_size; - OCStackResult result; OicSecAcl_t *oic_acl1 = NULL; OicSecAcl_t *oic_acl2 = NULL; struct icl_provisioning_pairwise_devices_cb_container *container; @@ -1209,8 +1259,14 @@ API int iotcon_provisioning_pairwise_devices(iotcon_provisioning_device_h device container->cb = cb; container->user_data = user_data; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCProvisionPairwiseDevices(container, + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _provisioning_pairwise_devices_cb_container_destroy(container); + return ret; + } + + ret = OCProvisionPairwiseDevices(container, SYMMETRIC_PAIR_WISE_KEY, key_size, icl_provisioning_device_get_device(container->device1), @@ -1218,11 +1274,11 @@ API int iotcon_provisioning_pairwise_devices(iotcon_provisioning_device_h device icl_provisioning_device_get_device(container->device2), oic_acl2, _provisioning_pairwise_devices_cb); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCProvisionPairwiseDevces() Fail(%d)", result); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCProvisionPairwiseDevces() Fail(%d)", ret); _provisioning_pairwise_devices_cb_container_destroy(container); - return _provisioning_parse_oic_error(result); + return _provisioning_parse_oic_error(ret); } return IOTCON_ERROR_NONE; @@ -1287,7 +1343,6 @@ API int iotcon_provisioning_unlink_pairwise(iotcon_provisioning_device_h device1 { FN_CALL; int ret; - OCStackResult result; struct icl_provisioning_unlink_pairwise_cb_container *container; RETV_IF(false == ic_utils_check_ocf_feature(), IOTCON_ERROR_NOT_SUPPORTED); @@ -1318,16 +1373,22 @@ API int iotcon_provisioning_unlink_pairwise(iotcon_provisioning_device_h device1 container->cb = cb; container->user_data = user_data; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCUnlinkDevices(container, + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _provisioning_unlink_pairwise_cb_container_destroy(container); + return ret; + } + + ret = OCUnlinkDevices(container, icl_provisioning_device_get_device(container->device1), icl_provisioning_device_get_device(container->device2), _provisioning_unlink_pairwise_cb); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCUnlinkDevices() Fail(%d)", result); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCUnlinkDevices() Fail(%d)", ret); _provisioning_unlink_pairwise_cb_container_destroy(container); - return _provisioning_parse_oic_error(result); + return _provisioning_parse_oic_error(ret); } return IOTCON_ERROR_NONE; @@ -1380,17 +1441,23 @@ static void _provisioning_remove_device_cb(void *ctx, int n_of_res, static void* _provisioning_remove_device_thread(void *user_data) { FN_CALL; - OCStackResult result; + int ret; struct icl_provisioning_remove_device_cb_container *container = user_data; - ic_utils_mutex_lock(IC_UTILS_MUTEX_IOTY); - result = OCRemoveDevice(container, + ret = icl_ioty_mutex_lock(); + if (IOTCON_ERROR_NONE != ret) { + ERR("icl_ioty_mutex_lock() Fail(%d)", ret); + _provisioning_remove_cb_container_destroy(container); + return NULL; + } + + ret = OCRemoveDevice(container, container->timeout, icl_provisioning_device_get_device(container->device), _provisioning_remove_device_cb); - ic_utils_mutex_unlock(IC_UTILS_MUTEX_IOTY); - if (OC_STACK_OK != result) { - ERR("OCRemoveDevice() Fail(%d)", result); + icl_ioty_mutex_unlock(); + if (OC_STACK_OK != ret) { + ERR("OCRemoveDevice() Fail(%d)", ret); _provisioning_remove_cb_container_destroy(container); return NULL; } diff --git a/lib/icl.c b/lib/icl.c index dbb0dbb..3a52ad9 100644 --- a/lib/icl.c +++ b/lib/icl.c @@ -48,8 +48,7 @@ int icl_initialize(const char *file_path, bool is_pt) } ic_utils_mutex_lock(IC_UTILS_MUTEX_INIT); - icl_init_count++; - if (1 == icl_init_count) { + if (0 == icl_init_count) { ret = icl_ioty_init(&icl_thread); if (IOTCON_ERROR_NONE != ret) { ERR("icl_ioty_init() Fail(%d)", ret); @@ -65,6 +64,7 @@ int icl_initialize(const char *file_path, bool is_pt) return ret; } } + icl_init_count++; ic_utils_mutex_unlock(IC_UTILS_MUTEX_INIT); return IOTCON_ERROR_NONE; diff --git a/test/iotcon-test-device-client.c b/test/iotcon-test-device-client.c index 75415cd..55ec377 100644 --- a/test/iotcon-test-device-client.c +++ b/test/iotcon-test-device-client.c @@ -180,7 +180,7 @@ int main(int argc, char **argv) loop = g_main_loop_new(NULL, FALSE); /* initialize iotcon */ - ret = iotcon_initialize(NULL); + ret = iotcon_initialize("/usr/bin/iotcon-test-svr-db-client.dat"); if (IOTCON_ERROR_NONE != ret) { ERR("iotcon_initialize() Fail(%d)", ret); return -1;