NSTopicLL * NSProviderGetConsumerTopicsCacheData(NSCacheList * regTopicList,
NSCacheList * conTopicList, const char * consumerId)
{
NS_LOG(DEBUG, "NSProviderGetConsumerTopicsCacheData - IN");
pthread_mutex_lock(&NSCacheMutex);
NSTopicLL * topics = NSProviderGetTopicsCacheData(regTopicList);
if (!topics)
{
pthread_mutex_unlock(&NSCacheMutex);
return NULL;
}
NSCacheElement * iter = conTopicList->head;
conTopicList->cacheType = NS_PROVIDER_CACHE_CONSUMER_TOPIC_CID;
while (iter)
{
NSCacheTopicSubData * curr = (NSCacheTopicSubData *)iter->data;
if (curr && strcmp(curr->id, consumerId) == 0)
{
NS_LOG_V(INFO_PRIVATE, "curr->id = %s", curr->id);
NS_LOG_V(DEBUG, "curr->topicName = %s", curr->topicName);
NSTopicLL * topicIter = topics;
while (topicIter)
{
if (strcmp(topicIter->topicName, curr->topicName) == 0)
{
topicIter->state = NS_TOPIC_SUBSCRIBED;
break;
}
topicIter = topicIter->next;
}
}
iter = iter->next;
}
conTopicList->cacheType = NS_PROVIDER_CACHE_CONSUMER_TOPIC_NAME;
pthread_mutex_unlock(&NSCacheMutex);
NS_LOG(DEBUG, "NSProviderGetConsumerTopics - OUT");
return topics;
}
NSCacheElement * NSProviderStorageRead(NSCacheList * list, const char * findId)
{
pthread_mutex_lock(&NSCacheMutex);
NS_LOG(DEBUG, "NSCacheRead - IN");
NSCacheElement * iter = list->head;
NSCacheElement * next = NULL;
NSCacheType type = list->cacheType;
NS_LOG_V(INFO_PRIVATE, "Find ID - %s", findId);
while (iter)
{
next = iter->next;
if (NSProviderCompareIdCacheData(type, iter->data, findId))
{
NS_LOG(DEBUG, "Found in Cache");
pthread_mutex_unlock(&NSCacheMutex);
return iter;
}
iter = next;
}
NS_LOG(DEBUG, "Not found in Cache");
NS_LOG(DEBUG, "NSCacheRead - OUT");
pthread_mutex_unlock(&NSCacheMutex);
return NULL;
}
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;
}
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);
}
void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage * msg)
{
NS_VERIFY_NOT_NULL_V(msg);
NS_LOG_V(DEBUG, "confirmed by : %s", msg->providerId);
NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
NS_VERIFY_NOT_NULL_V(provider);
if (provider->connection->next == NULL)
{
NS_LOG(DEBUG, "call back to user");
NSSubscriptionAccepted((NSProvider *) provider);
}
}
OCStackApplicationResult NSHandlePublishCb(void *ctx, OCDoHandle handle,
OCClientResponse *clientResponse)
{
(void) handle;
if (ctx != (void *)DEFAULT_CONTEXT_VALUE)
{
NS_LOG(DEBUG, "Invalid publish callback received");
}
NS_LOG_V(DEBUG, "Publish resource response received code: %d", clientResponse->result);
return OC_STACK_KEEP_TRANSACTION;
}
void NSPushQueue(NSSchedulerType schedulerType, NSTaskType taskType, void* data)
{
if(!NSIsRunning[schedulerType])
{
return;
}
pthread_mutex_lock(&NSMutex[schedulerType]);
NS_LOG(DEBUG, "NSPushQueue - IN");
NS_LOG_V(DEBUG, "NSSchedulerType = %d", schedulerType);
NS_LOG_V(DEBUG, "NSTaskType = %d", taskType);
if (NSHeadMsg[schedulerType] == NULL)
{
NSHeadMsg[schedulerType] = (NSTask*) OICMalloc(sizeof(NSTask));
NSHeadMsg[schedulerType]->taskType = taskType;
NSHeadMsg[schedulerType]->taskData = data;
NSHeadMsg[schedulerType]->nextTask = NULL;
NSTailMsg[schedulerType] = NSHeadMsg[schedulerType];
}
else
{
NSTask* newNode = (NSTask*) OICMalloc(sizeof(NSTask));
newNode->taskType = taskType;
newNode->taskData = data;
newNode->nextTask = NULL;
NSTailMsg[schedulerType]->nextTask = newNode;
NSTailMsg[schedulerType] = newNode;
}
sem_post(&(NSSemaphore[schedulerType]));
NS_LOG(DEBUG, "NSPushQueue - OUT");
pthread_mutex_unlock(&NSMutex[schedulerType]);
}
NSResult NSPublishResourceToCloud(char *serverAddress)
{
NS_LOG(DEBUG, "NSPublishResourceToCloud - IN");
NS_LOG_V(DEBUG, "Cloud address: %s", serverAddress);
const char * publishQuery = "/oic/rd?rt=oic.wk.rdpub";
if (NSCloudPublish(serverAddress, publishQuery, &NSHandlePublishCb, 1,
NotificationResource.handle) != OC_STACK_OK)
{
NS_LOG(DEBUG, "Unable to publish resources to cloud");
}
NS_LOG(DEBUG, "NSPublishResourceToCloud - OUT");
return NS_OK;
}
NSResult NSConsumerStorageWrite(NSCacheList * list, NSCacheElement * newObj)
{
NS_VERIFY_NOT_NULL(list, NS_ERROR);
NS_VERIFY_NOT_NULL(newObj, NS_ERROR);
NSCacheType type = list->cacheType;
NS_LOG_V(DEBUG, "cache type : %d", type);
if (type == NS_CONSUMER_CACHE_PROVIDER)
{
return NSConsumerCacheWriteProvider(list, newObj);
}
NS_LOG (ERROR, "Not Supported Type");
return NS_ERROR;
}
NSResult NSCacheUpdateSubScriptionState(NSCacheList * list, char * id, bool state)
{
pthread_mutex_lock(&NSCacheMutex);
NS_LOG(DEBUG, "NSCacheUpdateSubScriptionState - IN");
if (id == NULL)
{
NS_LOG(DEBUG, "id is NULL");
pthread_mutex_unlock(&NSCacheMutex);
return NS_ERROR;
}
NSCacheElement * it = NSProviderStorageRead(list, id);
if (it)
{
NSCacheSubData * itData = (NSCacheSubData *) it->data;
if (strcmp(itData->id, 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(DEBUG, "update state = %d", state);
itData->isWhite = state;
NS_LOG(DEBUG, "Update Data - OUT");
pthread_mutex_unlock(&NSCacheMutex);
return NS_OK;
}
}
else
{
NS_LOG(DEBUG, "Not Found Data");
}
NS_LOG(DEBUG, "NSCacheUpdateSubScriptionState - OUT");
pthread_mutex_unlock(&NSCacheMutex);
return NS_ERROR;
}
OCStackResult NSProviderPublishTopic(OCRepPayload * payload, OCClientResponseHandler response)
{
NS_LOG(DEBUG, "NSProviderPublishTopic - IN");
OCCallbackData cbData;
memset(&cbData, 0, sizeof(OCCallbackData));
cbData.cb = response;
cbData.cd = NULL;
cbData.context = NULL;
NSMQServerInfo * serverInfo = NSGetMQServerInfo();
if (!serverInfo)
{
NS_LOG(DEBUG, "serverInfo is not NULL");
NS_LOG_V(DEBUG, "serverInfo->serverUri = %s", serverInfo->serverUri);
}
NS_LOG(DEBUG, "NSProviderPublishTopic - OUT");
return OCDoResource(NULL, OC_REST_POST, serverInfo->serverUri, serverInfo->devAddr,
(OCPayload *)payload, CT_ADAPTER_TCP, OC_LOW_QOS, &cbData, NULL, 0);
}
NSResult NSSendSync(NSSyncInfo *sync)
{
NS_LOG(DEBUG, "NSSendSync - IN");
OCObservationId obArray[255] = { 0, };
int obCount = 0;
int i;
OCResourceHandle rHandle;
if (NSPutSyncResource(sync, &rHandle) != NS_OK)
{
NS_LOG(ERROR, PCF("Fail to put sync resource"));
return NS_ERROR;
}
NSCacheElement * it = consumerSubList->head;
while (it)
{
NSCacheSubData * subData = (NSCacheSubData *) it->data;
NS_LOG_V(INFO_PRIVATE, "sync subData->id = %s", subData->id);
NS_LOG_V(DEBUG, "subData->messageId = %d", subData->messageObId);
NS_LOG_V(DEBUG, "subData->cloud_messageId = %d", subData->remote_messageObId);
NS_LOG_V(DEBUG, "subData->syncId = %d", subData->syncObId);
NS_LOG_V(DEBUG, "subData->cloud_syncId = %d", subData->remote_syncObId);
NS_LOG_V(DEBUG, "subData->isWhite = %d", subData->isWhite);
if (subData->isWhite)
{
if (subData->syncObId != 0)
{
obArray[obCount++] = subData->syncObId;
}
#if (defined WITH_CLOUD)
if (subData->remote_syncObId != 0)
{
obArray[obCount++] = subData->remote_syncObId;
}
#endif
}
it = it->next;
}
OCRepPayload* payload = NULL;
if (NSSetSyncPayload(sync, &payload) != NS_OK)
{
NS_LOG(ERROR, "Failed to allocate payload");
return NS_ERROR;
}
#ifdef WITH_MQ
if (NSGetMQServerInfo())
{
OCRepPayload* MQPayload = OCRepPayloadClone(payload);
NSMessageType MQType = 0;
if (sync->state == NS_SYNC_READ)
{
MQType = NS_MESSAGE_READ;
}
else if (sync->state == NS_SYNC_DELETED)
{
MQType = NS_MESSAGE_DELETED;
}
OCRepPayloadSetPropInt(MQPayload, NS_ATTRIBUTE_TYPE, (int64_t) MQType);
NSProviderPublishTopic(MQPayload, NSProviderPublishMQResponseCB);
}
#endif
for (i = 0; i < obCount; ++i)
{
NS_LOG(DEBUG, "-------------------------------------------------------message\n");
NS_LOG_V(DEBUG, "Sync WhiteList[%d] = %d", i, obArray[i]);
NS_LOG(DEBUG, "-------------------------------------------------------message\n");
}
OCStackResult ocstackResult = OCNotifyListOfObservers(rHandle, obArray,
obCount, payload, OC_LOW_QOS);
NS_LOG_V(DEBUG, "Sync ocstackResult = %d", ocstackResult);
if (ocstackResult != OC_STACK_OK)
{
NS_LOG(ERROR, "fail to send Sync");
OCRepPayloadDestroy(payload);
return NS_ERROR;
}
OCRepPayloadDestroy(payload);
NS_LOG(DEBUG, "NSSendSync - OUT");
return NS_OK;
}
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 NSSendNotification(NSMessage *msg)
{
NS_LOG(DEBUG, "NSSendMessage - IN");
OCResourceHandle rHandle;
OCObservationId obArray[255] = { 0, };
int obCount = 0, i;
if (NSPutMessageResource(msg, &rHandle) != NS_OK)
{
NS_LOG(ERROR, "fail to Put notification resource");
return NS_ERROR;
}
OCRepPayload* payload = NULL;
if (NSSetMessagePayload(msg, &payload) != NS_OK)
{
NS_LOG(ERROR, "fail to Get message payload");
return NS_ERROR;
}
#ifdef WITH_MQ
if (NSGetMQServerInfo())
{
NSProviderPublishTopic(OCRepPayloadClone(payload), NSProviderPublishMQResponseCB);
}
#endif
if (consumerSubList->head == NULL)
{
NS_LOG(ERROR, "SubList->head is NULL, empty SubList");
OCRepPayloadDestroy(payload);
msg->extraInfo = NULL;
return NS_ERROR;
}
NSCacheElement * it = consumerSubList->head;
while (it)
{
NSCacheSubData * subData = (NSCacheSubData *) it->data;
NS_LOG_V(INFO_PRIVATE, "message subData->id = %s", subData->id);
NS_LOG_V(DEBUG, "subData->messageId = %d", subData->messageObId);
NS_LOG_V(DEBUG, "subData->cloud_messageId = %d", subData->remote_messageObId);
NS_LOG_V(DEBUG, "subData->syncId = %d", subData->syncObId);
NS_LOG_V(DEBUG, "subData->cloud_syncId = %d", subData->remote_syncObId);
NS_LOG_V(DEBUG, "subData->isWhite = %d", subData->isWhite);
if (subData->isWhite)
{
if(subData->messageObId != 0)
{
if (msg->topic && (msg->topic)[0] != '\0')
{
NS_LOG_V(DEBUG, "this is topic message: %s", msg->topic);
if (NSProviderIsTopicSubScribed(consumerTopicList->head, subData->id, msg->topic))
{
obArray[obCount++] = subData->messageObId;
}
}
else
{
obArray[obCount++] = subData->messageObId;
}
}
#if (defined WITH_CLOUD)
if (subData->remote_messageObId != 0)
{
if (msg->topic && (msg->topic)[0] != '\0')
{
NS_LOG_V(DEBUG, "this is topic message via remote server: %s", msg->topic);
if (NSProviderIsTopicSubScribed(consumerTopicList->head, subData->id, msg->topic))
{
obArray[obCount++] = subData->remote_messageObId;
}
}
else
{
obArray[obCount++] = subData->remote_messageObId;
}
}
#endif
}
it = it->next;
}
for (i = 0; i < obCount; ++i)
{
NS_LOG(DEBUG, "-------------------------------------------------------message\n");
NS_LOG_V(DEBUG, "SubScription WhiteList[%d] = %d", i, obArray[i]);
NS_LOG(DEBUG, "-------------------------------------------------------message\n");
}
if (!obCount)
{
NS_LOG(ERROR, "observer count is zero");
OCRepPayloadDestroy(payload);
msg->extraInfo = NULL;
return NS_ERROR;
}
OCStackResult ocstackResult = OCNotifyListOfObservers(rHandle, obArray, obCount, payload,
OC_LOW_QOS);
NS_LOG_V(DEBUG, "Message ocstackResult = %d", ocstackResult);
if (ocstackResult != OC_STACK_OK)
{
NS_LOG(ERROR, "fail to send message");
OCRepPayloadDestroy(payload);
msg->extraInfo = NULL;
return NS_ERROR;
}
OCRepPayloadDestroy(payload);
msg->extraInfo = NULL;
NS_LOG(DEBUG, "NSSendMessage - OUT");
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 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;
}
bool NSProviderCompareIdCacheData(NSCacheType type, void * data, const char * id)
{
NS_LOG(DEBUG, "NSProviderCompareIdCacheData - IN");
if (data == NULL)
{
return false;
}
NS_LOG_V(INFO_PRIVATE, "Data(compData) = [%s]", id);
if (type == NS_PROVIDER_CACHE_SUBSCRIBER)
{
NSCacheSubData * subData = (NSCacheSubData *) data;
NS_LOG_V(INFO_PRIVATE, "Data(subData) = [%s]", subData->id);
if (strcmp(subData->id, id) == 0)
{
NS_LOG(DEBUG, "SubData is Same");
return true;
}
NS_LOG(DEBUG, "Message Data is Not Same");
return false;
}
else if (type == NS_PROVIDER_CACHE_SUBSCRIBER_OBSERVE_ID)
{
NSCacheSubData * subData = (NSCacheSubData *) data;
NS_LOG_V(INFO_PRIVATE, "Data(subData) = [%s]", subData->id);
OCObservationId currID = *id;
if (NSIsSameObId(subData, currID))
{
NS_LOG(DEBUG, "SubData is Same");
return true;
}
NS_LOG(DEBUG, "Message Data is Not Same");
return false;
}
else if (type == NS_PROVIDER_CACHE_REGISTER_TOPIC)
{
NSCacheTopicData * topicData = (NSCacheTopicData *) data;
NS_LOG_V(DEBUG, "Data(topicData) = [%s]", topicData->topicName);
if (strcmp(topicData->topicName, id) == 0)
{
NS_LOG(DEBUG, "SubData is Same");
return true;
}
NS_LOG(DEBUG, "Message Data is Not Same");
return false;
}
else if (type == NS_PROVIDER_CACHE_CONSUMER_TOPIC_NAME)
{
NSCacheTopicSubData * topicData = (NSCacheTopicSubData *) data;
NS_LOG_V(DEBUG, "Data(topicData) = [%s]", topicData->topicName);
if (strcmp(topicData->topicName, id) == 0)
{
NS_LOG(DEBUG, "SubData is Same");
return true;
}
NS_LOG(DEBUG, "Message Data is Not Same");
return false;
}
else if (type == NS_PROVIDER_CACHE_CONSUMER_TOPIC_CID)
{
NSCacheTopicSubData * topicData = (NSCacheTopicSubData *) data;
NS_LOG_V(INFO_PRIVATE, "Data(topicData) = [%s]", topicData->id);
if (strcmp(topicData->id, id) == 0)
{
NS_LOG(DEBUG, "SubData is Same");
return true;
}
NS_LOG(DEBUG, "Message Data is Not Same");
return false;
}
NS_LOG(DEBUG, "NSProviderCompareIdCacheData - OUT");
return false;
}
void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
{
NS_VERIFY_NOT_NULL_V(provider);
bool isAdded = true;
bool isSubscribing = false;
NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
if (providerCacheData == NULL)
{
isAdded = false;
}
else
{
providerCacheData->accessPolicy = provider->accessPolicy;
NSProviderConnectionInfo * infos = providerCacheData->connection;
OCTransportAdapter newAdapter = provider->connection->addr->adapter;
while (infos)
{
isSubscribing |= infos->isSubscribing;
if (infos->addr->adapter == newAdapter && infos->isSubscribing == true)
{
NS_LOG_V(DEBUG, "This provider already discovered : %s:%d",
infos->addr->addr, infos->addr->port);
NS_LOG_V(DEBUG, "Subscription : %d", infos->isSubscribing);
return;
}
infos = infos->next;
}
}
NSResult ret = NSProviderCacheUpdate(provider);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
if (isAdded == false)
{
NS_LOG(DEBUG, "New provider is discovered");
}
else
{
provider = providerCacheData;
NS_LOG(DEBUG, "provider's connection is updated.");
}
if (provider->accessPolicy == NS_SELECTION_CONSUMER && isSubscribing == false)
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
NSDiscoveredProvider((NSProvider *) provider);
}
else
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
NSProvider_internal * subProvider = NSCopyProvider(provider);
NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) subProvider);
NS_VERIFY_NOT_NULL_V(task);
NSConsumerPushEvent(task);
}
NSRemoveProvider(providerCacheData);
}
