check init

Change-Id: Ie021c2967e5d79aa868ea022fda9e43f04dabf87
Signed-off-by: youngman <yman.jung@samsung.com>

diff --git a/lib/icl-ioty-ocprocess.c b/lib/icl-ioty-ocprocess.c
index 3d2d99b3c678e16b02d2c215b6ed4edf0d9b43f4..67a571d0129cc46a32a32843ccd7a73b8b8da89d 100644 (file)
--- 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 8bbfb37e537c5da2111732d8bb7f503e97bbc909..5105ea2b61050af6e6c77d9768b2e396b72b2344 100644 (file)
--- 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 e93494d25410b2966c9373a013cbb4c6354d6320..f58a916d94d128e20de6efa17bab2372dd48d89b 100644 (file)
--- 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 50b32c52d11ed0df358a5a897703ccd5cfe69212..bbf21534407843212edb9f2003171f0de81f55b5 100644 (file)
--- 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 dbb0dbba6030fd7b11d5da95716e297f936ddf32..3a52ad9ca520e384ca735fd4e99caa296d11ba9a 100644 (file)
--- 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 75415cd1a5a6f606c7117aeb269c24a70ba457bc..55ec37758572f9bf1a521b6bba212c4469b953e5 100644 (file)
--- 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;