From a61ef7362b7aeaac8a94d2a20bf415228e24d380 Mon Sep 17 00:00:00 2001 From: "saerome.kim" Date: Wed, 31 Jan 2018 17:27:19 +0900 Subject: [PATCH] mot-agent: add mutex at every APIs which goes to CA layer Signed-off-by: saerome.kim --- src/mot-agent/ma-subowner.c | 131 ++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 125 insertions(+), 6 deletions(-) diff --git a/src/mot-agent/ma-subowner.c b/src/mot-agent/ma-subowner.c index 4d66fe2..2a00ada 100644 --- a/src/mot-agent/ma-subowner.c +++ b/src/mot-agent/ma-subowner.c @@ -137,6 +137,7 @@ typedef struct _ma_subowner { } ma_subowner_s; ma_subowner_s *g_client; +GMutex iotivity_mutex; #define CASE_TO_STR(x) case x: return #x; const char* _error_to_string(OCStackResult err) @@ -379,21 +380,101 @@ static FILE* _fopen_prvn_mng(const char* path, const char* mode) return fopen(data_dir, mode); } +#ifdef THREAD_COND_WAIT_USED +/* + * data structure + */ +typedef struct _proc { + char name[2]; + int data; + pthread_t thread; + pthread_mutex_t lock; + pthread_cond_t cond; + long int waits; +} PROC; +void _exec_and_wait(void* args) { + OCStackResult ret = OC_STACK_OK; + static struct timespec time_to_wait = {0, 0}; + PROC *proc = (PROC*) args; + int TIMES = proc->waits /100; + + time_to_wait.tv_sec = time(NULL) + proc->waits / 1000; + time_to_wait.tv_nsec = (proc->waits % 1000) * 1000000; + + MA_LOGE("before increase proc[%s] data to [%d]", proc->name, proc->data); + + while(g_client->g_doneCB && proc->data < TIMES) { + MA_LOGE("increase proc[%s] data to [%d]", proc->name, proc->data); + pthread_mutex_lock(&proc->lock); + pthread_cond_timedwait(&proc->cond, &proc->lock, &time_to_wait); + proc->data++; + + ret = OCProcess(); + if (OC_STACK_OK != ret) { + MA_LOGE( "OCStack process error = %d", ret); + proc->data = TIMES; + } + + pthread_mutex_unlock(&proc->lock); + } +} + +int _init_proc(PROC *proc, void *(*routine) (void *)) { + pthread_attr_t attr; + + MA_LOGI("try to init proc [%s]", proc->name); + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); + + pthread_mutex_init(&proc->lock, NULL); + pthread_cond_init(&proc->cond, NULL); + + pthread_create(&proc->thread, &attr, routine, (void*) proc); + pthread_attr_destroy(&attr); + + return MA_ERROR_NONE; +} +#endif static int _wait_cb_ret(int msec) { OCStackResult ret = OC_STACK_OK; +#ifndef THREAD_COND_WAIT_USED + struct timespec request, remaining; + request.tv_sec = msec / 1000; + request.tv_nsec = (msec % 1000) * 1000000; +#endif + ma_check_null_ret_error("g_client", g_client, OC_STACK_INVALID_PARAM); +#ifdef THREAD_COND_WAIT_USED + int result_a = 0; + PROC proc_a; + + strcpy(proc_a.name, "A\0"); + proc_a.data = 0; + proc_a.waits = msec; + + if (MA_ERROR_NONE !=_init_proc(&proc_a, _exec_and_wait)) + MA_LOGE("Fail to init proc [%s]", proc_a.name); + + pthread_join(proc_a.thread, (void*) &result_a); +#else for (int i=0; !g_client->g_doneCB && msec > i; ++i) { - usleep(1000); + ret = nanosleep(&request, &remaining); + if (-1 == ret && EINTR == errno) { + MA_LOGE( "Onanosleep error = %d", errno); + break; + } + g_mutex_lock(&iotivity_mutex); ret = OCProcess(); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret) { MA_LOGE( "OCStack process error = %d", ret); - return ret; + break; } } - +#endif if (!g_client->g_doneCB) OCPDMCleanupForTimeout(); @@ -479,13 +560,17 @@ static int _init_provision_client(void) if (g_client) return ret; + g_mutex_init(&iotivity_mutex); + snprintf(data_dir, MAX_FILE_PATH_LEN, "%s/network/%s", "/opt/usr/data", PRVN_DB_FILE_NAME); /* initialize persistent storage for SVR DB */ static OCPersistentStorage ps = { _fopen_prvn_mng, fread, fwrite, fclose, unlink }; + g_mutex_lock(&iotivity_mutex); ret = OCRegisterPersistentStorageHandler(&ps); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret ) { MA_LOGE( "OCRegisterPersistentStorageHandler error = %d", ret); return ret; @@ -494,19 +579,25 @@ static int _init_provision_client(void) _set_device_id_seed(); /* initialize OC stack and provisioning manager */ + g_mutex_lock(&iotivity_mutex); ret = OCInit(NULL, 0, OC_CLIENT_SERVER); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret ) { MA_LOGE( "OCInit() error = [%d][%s]", ret, _error_to_string(ret)); return ret; } /* Do Self-Ownership Transfer */ + g_mutex_lock(&iotivity_mutex); ret = OCConfigSelfOwnership(); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret ) { MA_LOGE( "OCConfigSelfOwnership() error = [%d][%s]", ret, _error_to_string(ret)); } + g_mutex_lock(&iotivity_mutex); ret = OCInitPM(data_dir); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret ) { MA_LOGE( "OCInitPM() error = [%d][%s]", ret, _error_to_string(ret)); return ret; @@ -762,12 +853,16 @@ static gboolean _ma_timeout_cb(gpointer data) #endif static gpointer _disc_mot_env_devs_func(gpointer data) { + int ret = OC_STACK_OK; ma_req_cb_s *con = (ma_req_cb_s *)data; ma_check_null_ret_error("con", con, NULL); MA_LOGI("Discovering Multiple Ownership Transfer enabled Devices on Network.."); - if (OC_STACK_OK != OCDiscoverMultipleOwnerEnabledDevices(con->timeout, - &g_client->g_motdev_list)) { + + g_mutex_lock(&iotivity_mutex); + OCDiscoverMultipleOwnerEnabledDevices(con->timeout, &g_client->g_motdev_list); + g_mutex_unlock(&iotivity_mutex); + if (OC_STACK_OK != ret) { MA_LOGE( "OCDiscoverMultipleOwnerEnalbedDevices API error"); goto DISC_MOT_ENB_DEVS_END; } @@ -829,7 +924,9 @@ static gpointer _disc_owned_devs_func(gpointer data) _remove_owned_client(); MA_LOGD("Discovering Multiple Owned Devices"); + g_mutex_lock(&iotivity_mutex); ret = OCDiscoverMultipleOwnedDevices(con->timeout, &g_client->g_mowned_list); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret) { MA_LOGE( "OCDiscoverMultipleOwnerEnabledDevices API error"); goto DISC_OWNED_DEVS_END; @@ -2103,14 +2200,19 @@ static gpointer _pair_func(gpointer data) if(OIC_PRECONFIG_PIN == src_dev->doxm->oxmSel) { /* Pre-Configured PIN initialization */ const char* testPreconfigPin = con->pin;/* Ex) "12341234" */ + g_mutex_lock(&iotivity_mutex); ret = OCAddPreconfigPin(src_dev, testPreconfigPin, strlen(testPreconfigPin)); + g_mutex_unlock(&iotivity_mutex); if(OC_STACK_OK != ret) { MA_LOGE("Failed to save the pre-configured PIN"); MA_LOGE("You can't use the pre-configured PIN OxM for MOT"); goto PVPAIR_ERROR; } } + + g_mutex_lock(&iotivity_mutex); ret = OCDoMultipleOwnershipTransfer(g_client, src_dev, _mot_cb); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret ) { MA_LOGE( "OCDoMultipleOwnershipTransfer: ret = %d (%s)", ret, _error_to_string(ret)); goto PVPAIR_ERROR; @@ -2148,9 +2250,11 @@ static gpointer _pair_func(gpointer data) goto PVPAIR_ERROR; } + g_mutex_lock(&iotivity_mutex); ret = OCProvisionPairwiseDevices((void*) g_client, SYMMETRIC_PAIR_WISE_KEY, OWNER_PSK_LENGTH_256, target_dev_1, acl_1, target_dev_2, acl_2, _pairwise_cb); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret) { MA_LOGD( "OCProvisionPairwiseDevices API error: %d (%s)", ret, _error_to_string(ret)); @@ -2275,7 +2379,9 @@ static gpointer _unpair_func(gpointer data) g_client->g_doneCB = false; MA_LOGI("Unlink Selected Pairwise Devices.."); + g_mutex_lock(&iotivity_mutex); ret = OCUnlinkDevices((void*) g_client, owner_dev, owned_dev, _unlink_cb ); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret) { MA_LOGD( "OCUnlinkDevices API error = %d (%s)", ret, _error_to_string(ret)); } else { @@ -2297,7 +2403,9 @@ static gpointer _unpair_func(gpointer data) goto PVUNPAIR_ERROR; } + g_mutex_lock(&iotivity_mutex); ret = OCRemoveSubOwner(g_client, owned_dev, &uuid_mowner, _remove_mo_cb); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret ) { MA_LOGE( "OCRemoveSubOwner: ret = %d (%s)", ret, _error_to_string(ret)); goto PVUNPAIR_ERROR; @@ -2315,8 +2423,10 @@ static gpointer _unpair_func(gpointer data) MA_LOGI(" Removing CRED for remote device at local SVR DB"); + g_mutex_lock(&iotivity_mutex); ret = OCRemoveDeviceWithUuid((void*) g_client, CALLBACK_TIMEOUT_5S, owned_uuid, _remove_remove_cred_local_cb ); + g_mutex_unlock(&iotivity_mutex); if (OC_STACK_OK != ret) { MA_LOGD( "OCRemoveDeviceWithUuid API error = %d (%s)", ret, _error_to_string(ret)); goto PVUNPAIR_ERROR; @@ -2729,16 +2839,25 @@ int ma_request_enable(ma_service *service) int ma_request_disable(ma_service *service) { + int ret = OC_STACK_OK; + NOTUSED(service); if (!g_client) return MA_ERROR_NONE; - if (OC_STACK_OK != OCStop()) { + g_mutex_lock(&iotivity_mutex); + ret = OCStop(); + g_mutex_unlock(&iotivity_mutex); + if (OC_STACK_OK != ret) { MA_LOGE( "OCStack stop error"); } + g_mutex_lock(&iotivity_mutex); OCTerminatePM(); + g_mutex_unlock(&iotivity_mutex); + + g_mutex_clear(&iotivity_mutex); if (g_client->g_mowned_list) { OCDeleteDiscoveredDevices(g_client->g_mowned_list); -- 2.7.4