NSResult NSProviderDeleteCacheData(NSCacheType type, void * data) { if (!data) { return NS_ERROR; } if (type == NS_PROVIDER_CACHE_SUBSCRIBER || type == NS_PROVIDER_CACHE_SUBSCRIBER_OBSERVE_ID) { NSCacheSubData * subData = (NSCacheSubData *) data; (subData->id)[0] = '\0'; NSOICFree(subData); return NS_OK; } else if (type == NS_PROVIDER_CACHE_REGISTER_TOPIC) { NSCacheTopicData * topicData = (NSCacheTopicData *) data; NS_LOG_V(DEBUG, "topicData->topicName = %s, topicData->state = %d", topicData->topicName, (int)topicData->state); NSOICFree(topicData->topicName); NSOICFree(topicData); } else if (type == NS_PROVIDER_CACHE_CONSUMER_TOPIC_NAME || type == NS_PROVIDER_CACHE_CONSUMER_TOPIC_CID) { NSCacheTopicSubData * topicData = (NSCacheTopicSubData *) data; NSOICFree(topicData->topicName); NSOICFree(topicData); } return NS_OK; }
NSResult NSConsumerStorageDestroy(NSCacheList * list) { NS_VERIFY_NOT_NULL(list, NS_ERROR); pthread_mutex_t * mutex = NSGetCacheMutex(); pthread_mutex_lock(mutex); NSCacheElement * iter = list->head; NSCacheElement * next = NULL; NSCacheType type = list->cacheType; if (type == NS_CONSUMER_CACHE_PROVIDER) { while (iter) { next = (NSCacheElement *) iter->next; NSRemoveProvider_internal((void *) iter->data); NSOICFree(iter); iter = next; } NSOICFree(list); } pthread_mutex_unlock(mutex); return NS_OK; }
void NSConsumerInternalTaskProcessing(NSTask * task) { NS_VERIFY_NOT_NULL_V(task); NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType); switch (task->taskType) { case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED: { NS_LOG(DEBUG, "Receive Subscribe confirm from provider."); NSConsumerHandleRecvSubscriptionConfirmed((NSMessage *)task->taskData); NSRemoveMessage((NSMessage *)task->taskData); break; } case TASK_CONSUMER_RECV_MESSAGE: { NS_LOG(DEBUG, "Receive New Notification"); NSConsumerHandleRecvMessage((NSMessage *)task->taskData); NSRemoveMessage((NSMessage *)task->taskData); break; } case TASK_CONSUMER_PROVIDER_DISCOVERED: { NS_LOG(DEBUG, "Receive New Provider is discovered."); NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData); NSRemoveProvider((NSProvider_internal *)task->taskData); break; } case TASK_RECV_SYNCINFO: { NS_LOG(DEBUG, "Receive SyncInfo."); NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData); NSOICFree(task->taskData); break; } case TASK_MAKE_SYNCINFO: { NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr"); NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData); NSOICFree(task->taskData); break; } case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL: { NS_LOG(DEBUG, "Make Subscribe cancel from provider."); NSConsumerHandleProviderDeleted((NSProvider_internal *)task->taskData); NSRemoveProvider((NSProvider_internal *)task->taskData); break; } default : { NS_LOG(ERROR, "Unknown TASK Type"); return ; } } NSOICFree(task); }
NSResult NSProviderStorageDelete(NSCacheList * list, const char * delId) { pthread_mutex_lock(&NSCacheMutex); NSCacheElement * prev = list->head; NSCacheElement * del = list->head; NSCacheType type = list->cacheType; if (!del) { NS_LOG(DEBUG, "list head is NULL"); pthread_mutex_unlock(&NSCacheMutex); return NS_FAIL; } if (NSProviderCompareIdCacheData(type, del->data, delId)) { if (del == list->head) // first object { if (del == list->tail) // first object (one object) { list->tail = del->next; } list->head = del->next; NSProviderDeleteCacheData(type, del->data); NSOICFree(del); pthread_mutex_unlock(&NSCacheMutex); return NS_OK; } } del = del->next; while (del) { if (NSProviderCompareIdCacheData(type, del->data, delId)) { if (del == list->tail) // delete object same to last object { list->tail = prev; } prev->next = del->next; NSProviderDeleteCacheData(type, del->data); NSOICFree(del); pthread_mutex_unlock(&NSCacheMutex); return NS_OK; } prev = del; del = del->next; } pthread_mutex_unlock(&NSCacheMutex); return NS_FAIL; }
NSResult NSProviderCacheUpdate(NSProvider_internal * provider) { NSCacheList * ProviderCache = *(NSGetProviderCacheList()); if (!ProviderCache) { NS_LOG(DEBUG, "Provider Cache Init"); ProviderCache = NSStorageCreate(); NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR); ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER; NSSetProviderCacheList(ProviderCache); } NS_VERIFY_NOT_NULL(provider, NS_ERROR); NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement)); NS_VERIFY_NOT_NULL(obj, NS_ERROR); obj->data = (NSCacheData *) provider; obj->next = NULL; NS_LOG(DEBUG, "try to write to storage"); NSResult ret = NSStorageWrite(ProviderCache, obj); NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL, NS_ERROR, NSOICFree(obj)); return NS_OK; }
void NSDestroyQueue(NSConsumerQueue * queue) { NS_VERIFY_NOT_NULL_V(queue); NSConsumerQueueObject * node = NSPopQueue(queue); while(node) { NSConsumerQueueObject * next = (NSConsumerQueueObject *)node->next; NSOICFree(node->data); NSOICFree(node); node = next; } NSOICFree(queue); }
NSResult NSProviderStorageDestroy(NSCacheList * list) { NSCacheElement * iter = list->head; NSCacheElement * next = NULL; NSCacheType type = list->cacheType; while (iter) { next = (NSCacheElement *) iter->next; NSProviderDeleteCacheData(type, iter->data); NSOICFree(iter); iter = next; } NSOICFree(list); return NS_OK; }
void NSThreadJoin(NSConsumerThread * handle) { NS_VERIFY_NOT_NULL_V(handle); if (handle->thread_id) { void * retData = NULL; pthread_join(handle->thread_id, & retData); NSOICFree(retData); } }
void * NSNotificationSchedule(void *ptr) { if (ptr == NULL) { NS_LOG(DEBUG, "Create NSNotifiactionSchedule"); } while (NSIsRunning[NOTIFICATION_SCHEDULER]) { sem_wait(&NSSemaphore[NOTIFICATION_SCHEDULER]); pthread_mutex_lock(&NSMutex[NOTIFICATION_SCHEDULER]); if (NSHeadMsg[NOTIFICATION_SCHEDULER] != NULL) { NSTask *node = NSHeadMsg[NOTIFICATION_SCHEDULER]; NSHeadMsg[NOTIFICATION_SCHEDULER] = node->nextTask; switch (node->taskType) { case TASK_SEND_NOTIFICATION: { NS_LOG(DEBUG, "CASE TASK_SEND_NOTIFICATION : "); NSSendNotification((NSMessage *)node->taskData); NSFreeMessage((NSMessage *)node->taskData); } break; case TASK_SEND_READ: NS_LOG(DEBUG, "CASE TASK_SEND_READ : "); NSSendSync((NSSyncInfo*) node->taskData); NSFreeSync((NSSyncInfo*) node->taskData); break; case TASK_RECV_READ: NS_LOG(DEBUG, "CASE TASK_RECV_READ : "); NSSendSync((NSSyncInfo*) node->taskData); NSPushQueue(CALLBACK_RESPONSE_SCHEDULER, TASK_CB_SYNC, node->taskData); break; default: NS_LOG(ERROR, "Unknown type message"); break; } NSOICFree(node); } pthread_mutex_unlock(&NSMutex[NOTIFICATION_SCHEDULER]); } NS_LOG(INFO, "Destroy NSNotificationSchedule"); return NULL; }
void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync) { NS_VERIFY_NOT_NULL_V(sync); NSProvider_internal * provider = NSProviderCacheFind(sync->providerId); NS_VERIFY_NOT_NULL_V (provider); NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection); NS_VERIFY_NOT_NULL_V (connections); NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal)); NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo, NSRemoveConnections(connections)); OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId); syncInfo->messageId = sync->messageId; syncInfo->state = sync->state; syncInfo->connection = connections; NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo); NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo)); NSConsumerPushEvent(syncTask); }
NSResult NSMessageCacheUpdate(NSMessage * msg, NSSyncType type) { NS_VERIFY_NOT_NULL(msg, NS_ERROR); NSCacheList * MessageCache = *(NSGetMessageCacheList()); if (!MessageCache) { NS_LOG(DEBUG, "Message Cache Init"); MessageCache = NSStorageCreate(); NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR); MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE; NSSetMessageCacheList(MessageCache); } NSStoreMessage * sMsg = (NSStoreMessage *)OICMalloc(sizeof(NSStoreMessage)); NS_VERIFY_NOT_NULL(sMsg, NS_ERROR); NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement)); NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(obj, NS_ERROR, NSOICFree(sMsg)); sMsg->status = type; sMsg->msg = NSCopyMessage(msg); obj->data = (NSCacheData *) sMsg; obj->next = NULL; NS_LOG(DEBUG, "try to write to storage"); NSResult ret = NSStorageWrite(MessageCache, obj); NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL, NS_ERROR, NSRemoveCacheElementMessage(obj)); NSRemoveCacheElementMessage(obj); NS_LOG(DEBUG, "Update message done"); return NS_OK; }
void NSRemoveCacheElementMessage(NSCacheElement * obj) { NSRemoveMessage(((NSStoreMessage *)obj->data)->msg); NSOICFree(obj->data); NSOICFree(obj); }
NSResult NSProviderDeleteConsumerTopic(NSCacheList * conTopicList, NSCacheTopicSubData * topicSubData) { pthread_mutex_lock(&NSCacheMutex); char * cId = topicSubData->id; char * topicName = topicSubData->topicName; if (!conTopicList || !cId || !topicName) { pthread_mutex_unlock(&NSCacheMutex); return NS_ERROR; } NSCacheElement * prev = conTopicList->head; NSCacheElement * del = conTopicList->head; NSCacheType type = conTopicList->cacheType; if (!del) { NS_LOG(DEBUG, "list head is NULL"); pthread_mutex_unlock(&NSCacheMutex); return NS_FAIL; } NSCacheTopicSubData * curr = (NSCacheTopicSubData *) del->data; NS_LOG_V(INFO_PRIVATE, "compareid = %s", cId); NS_LOG_V(DEBUG, "comparetopicName = %s", topicName); NS_LOG_V(INFO_PRIVATE, "curr->id = %s", curr->id); NS_LOG_V(DEBUG, "curr->topicName = %s", curr->topicName); if ( (strncmp(curr->id, cId, NS_UUID_STRING_SIZE) == 0) && (strcmp(curr->topicName, topicName) == 0) ) { if (del == conTopicList->head) // first object { if (del == conTopicList->tail) // first object (one object) { conTopicList->tail = del->next; } conTopicList->head = del->next; NSProviderDeleteCacheData(type, del->data); NSOICFree(del); pthread_mutex_unlock(&NSCacheMutex); return NS_OK; } } curr = NULL; del = del->next; while (del) { curr = (NSCacheTopicSubData *) del->data; if ( (strncmp(curr->id, cId, NS_UUID_STRING_SIZE) == 0) && (strcmp(curr->topicName, topicName) == 0) ) { if (del == conTopicList->tail) // delete object same to last object { conTopicList->tail = prev; } prev->next = del->next; NSProviderDeleteCacheData(type, del->data); NSOICFree(del); pthread_mutex_unlock(&NSCacheMutex); return NS_OK; } prev = del; del = del->next; } pthread_mutex_unlock(&NSCacheMutex); return NS_FAIL; }
NSResult NSProviderStorageWrite(NSCacheList * list, NSCacheElement * newObj) { pthread_mutex_lock(&NSCacheMutex); NSCacheType type = list->cacheType; NS_LOG(DEBUG, "NSCacheWrite - IN"); if (newObj == NULL) { NS_LOG(DEBUG, "newObj is NULL - IN"); pthread_mutex_unlock(&NSCacheMutex); return NS_ERROR; } if (type == NS_PROVIDER_CACHE_SUBSCRIBER) { NS_LOG(DEBUG, "Type is SUBSCRIBER"); NSCacheSubData * subData = (NSCacheSubData *) newObj->data; NSCacheElement * it = NSProviderStorageRead(list, subData->id); if (it) { NSCacheSubData * itData = (NSCacheSubData *) it->data; if (strcmp(itData->id, subData->id) == 0) { NS_LOG(DEBUG, "Update Data - IN"); NS_LOG_V(INFO_PRIVATE, "currData_ID = %s", itData->id); NS_LOG_V(DEBUG, "currData_MsgObID = %d", itData->messageObId); NS_LOG_V(DEBUG, "currData_SyncObID = %d", itData->syncObId); NS_LOG_V(DEBUG, "currData_Cloud_MsgObID = %d", itData->remote_messageObId); NS_LOG_V(DEBUG, "currData_Cloud_SyncObID = %d", itData->remote_syncObId); NS_LOG_V(DEBUG, "currData_IsWhite = %d", itData->isWhite); NS_LOG_V(INFO_PRIVATE, "subData_ID = %s", subData->id); NS_LOG_V(DEBUG, "subData_MsgObID = %d", subData->messageObId); NS_LOG_V(DEBUG, "subData_SyncObID = %d", subData->syncObId); NS_LOG_V(DEBUG, "subData_Cloud_MsgObID = %d", subData->remote_messageObId); NS_LOG_V(DEBUG, "subData_Cloud_SyncObID = %d", subData->remote_syncObId); NS_LOG_V(DEBUG, "subData_IsWhite = %d", subData->isWhite); if (subData->messageObId != 0) { itData->messageObId = subData->messageObId; } if (subData->syncObId != 0) { itData->syncObId = subData->syncObId; } if (subData->remote_messageObId != 0) { itData->remote_messageObId = subData->remote_messageObId; } if (subData->remote_syncObId != 0) { itData->remote_syncObId = subData->remote_syncObId; NS_LOG_V(DEBUG, "sync id cached: %d", itData->remote_syncObId); } NS_LOG(DEBUG, "Update Data - OUT"); NSOICFree(subData); NSOICFree(newObj); pthread_mutex_unlock(&NSCacheMutex); return NS_OK; } } } else if (type == NS_PROVIDER_CACHE_REGISTER_TOPIC) { NS_LOG(DEBUG, "Type is REGITSTER TOPIC"); NSCacheTopicData * topicData = (NSCacheTopicData *) newObj->data; NSCacheElement * it = NSProviderStorageRead(list, topicData->topicName); NS_PROVIDER_DELETE_REGISTERED_TOPIC_DATA(it, topicData, newObj); } else if (type == NS_PROVIDER_CACHE_CONSUMER_TOPIC_NAME) { NS_LOG(DEBUG, "Type is REGITSTER TOPIC"); NSCacheTopicSubData * topicData = (NSCacheTopicSubData *) newObj->data; NSCacheElement * it = NSProviderStorageRead(list, topicData->topicName); NS_PROVIDER_DELETE_REGISTERED_TOPIC_DATA(it, topicData, newObj); } else if (type == NS_PROVIDER_CACHE_CONSUMER_TOPIC_CID) { NS_LOG(DEBUG, "Type is REGITSTER TOPIC"); NSCacheTopicSubData * topicData = (NSCacheTopicSubData *) newObj->data; NSCacheElement * it = NSProviderStorageRead(list, topicData->id); NS_PROVIDER_DELETE_REGISTERED_TOPIC_DATA(it, topicData, newObj); } if (list->head == NULL) { NS_LOG(DEBUG, "list->head is NULL, Insert First Data"); list->head = list->tail = newObj; pthread_mutex_unlock(&NSCacheMutex); return NS_OK; } list->tail = list->tail->next = newObj; NS_LOG(DEBUG, "list->head is not NULL"); pthread_mutex_unlock(&NSCacheMutex); return NS_OK; }
NSResult NSConsumerCacheWriteProvider(NSCacheList * list, NSCacheElement * newObj) { NS_VERIFY_NOT_NULL(list, NS_ERROR); NS_VERIFY_NOT_NULL(newObj, NS_ERROR); pthread_mutex_t * mutex = NSGetCacheMutex(); NSProvider_internal * newProvObj = (NSProvider_internal *) newObj->data; NSCacheElement * it = NSConsumerStorageRead(list, newProvObj->providerId); pthread_mutex_lock(mutex); if (it) { if (newProvObj->connection) { NSProvider_internal * provObj = (NSProvider_internal *) it->data; NSProviderConnectionInfo * infos = provObj->connection; NSProviderConnectionInfo * lastConn = infos->next; while(lastConn) { infos = lastConn; lastConn = lastConn->next; } infos->next = NSCopyProviderConnections(newProvObj->connection); } if (newProvObj->topicLL) { NSProvider_internal * provObj = (NSProvider_internal *) it->data; NSRemoveTopicLL(provObj->topicLL); provObj->topicLL = NSCopyTopicLL(newProvObj->topicLL); } pthread_mutex_unlock(mutex); return NS_OK; } NSCacheElement * obj = (NSCacheElement *) OICMalloc(sizeof(NSCacheElement)); NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(obj, NS_ERROR, pthread_mutex_unlock(mutex)); NS_LOG_V(INFO_PRIVATE, "New Object address : %s:%d", newProvObj->connection->addr->addr, newProvObj->connection->addr->port); obj->data = (void *) NSCopyProvider_internal(newProvObj); if (!obj->data) { NS_LOG (ERROR, "Failed to CopyProvider"); NSOICFree(obj); pthread_mutex_unlock(mutex); return NS_ERROR; } obj->next = NULL; if (!list->head) { list->head = obj; list->tail = obj; pthread_mutex_unlock(mutex); return NS_OK; } (list->tail)->next = obj; list->tail = obj; pthread_mutex_unlock(mutex); return NS_OK; }
NSResult NSConsumerStorageDelete(NSCacheList * list, const char * delId) { NS_VERIFY_NOT_NULL(list, NS_ERROR); NS_VERIFY_NOT_NULL(delId, NS_ERROR); NSCacheType type = list->cacheType; pthread_mutex_t * mutex = NSGetCacheMutex(); pthread_mutex_lock(mutex); NSCacheElement * prev = list->head; NSCacheElement * del = list->head; NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(del, NS_ERROR, pthread_mutex_unlock(mutex)); if (NSConsumerCompareIdCacheData(type, del->data, delId)) { if (del == list->head) { if (del == list->tail) { list->tail = del->next; } list->head = del->next; if (type == NS_CONSUMER_CACHE_PROVIDER) { NSRemoveProvider_internal((void *) del->data); } NSOICFree(del); pthread_mutex_unlock(mutex); return NS_OK; } } del = del->next; while (del) { if (NSConsumerCompareIdCacheData(type, del->data, delId)) { if (del == list->tail) { list->tail = prev; } prev->next = del->next; if (type == NS_CONSUMER_CACHE_PROVIDER) { NSRemoveProvider_internal((NSProvider_internal *) del->data); } NSOICFree(del); pthread_mutex_unlock(mutex); return NS_OK; } prev = del; del = del->next; } pthread_mutex_unlock(mutex); return NS_OK; }