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;
}
