{
NS_VERIFY_NOT_NULL_V(provider);
- NSProvider * retProvider = (NSProvider *)NSCopyProvider((NSProvider_internal *)provider);
+ NSProvider * retProvider = (NSProvider *)NSCopyProvider_internal((NSProvider_internal *)provider);
NS_VERIFY_NOT_NULL_V(retProvider);
NSConsumerThread * thread = NSThreadInit(NSDiscoveredProviderFunc, (void *) retProvider);
NSOICFree(provider);
}
-NSProvider_internal * NSCopyProvider(NSProvider_internal * prov)
+NSProvider_internal * NSCopyProvider_internal(NSProvider_internal * prov)
{
NS_VERIFY_NOT_NULL(prov, NULL);
return newProv;
}
-void NSRemoveProvider(NSProvider_internal * prov)
+NSProvider * NSCopyProvider(NSProvider_internal * prov)
+{
+ NS_VERIFY_NOT_NULL(prov, NULL);
+
+ NSProvider * newProv = (NSProvider *) OICMalloc(sizeof(NSProvider));
+ NS_VERIFY_NOT_NULL(newProv, NULL);
+
+ newProv->topicLL = NULL;
+
+ if (prov->topicLL)
+ {
+ NSTopicLL * topicList = NSCopyTopicLL(prov->topicLL);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(topicList, NULL, NSRemoveProvider(newProv));
+
+ newProv->topicLL = topicList;
+ }
+
+ OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
+
+ return newProv;
+}
+
+void NSRemoveProvider_internal(NSProvider_internal * prov)
{
NS_VERIFY_NOT_NULL_V(prov);
NSOICFree(prov);
}
+void NSRemoveProvider(NSProvider * prov)
+{
+ NS_VERIFY_NOT_NULL_V(prov);
+
+ if (prov->topicLL)
+ {
+ NSRemoveTopicLL(prov->topicLL);
+ }
+
+ NSOICFree(prov);
+}
+
NSSyncInfo_internal * NSCopySyncInfo(NSSyncInfo_internal * syncInfo)
{
NS_VERIFY_NOT_NULL(syncInfo, NULL);
NSProviderConnectionInfo * NSCopyProviderConnections(NSProviderConnectionInfo *);
void NSRemoveConnections(NSProviderConnectionInfo *);
-NSProvider_internal * NSCopyProvider(NSProvider_internal *);
-void NSRemoveProvider(NSProvider_internal *);
+NSProvider_internal * NSCopyProvider_internal(NSProvider_internal *);
+NSProvider * NSCopyProvider(NSProvider_internal *);
+void NSRemoveProvider_internal(NSProvider_internal *);
+void NSRemoveProvider(NSProvider *);
NSSyncInfo_internal * NSCopySyncInfo(NSSyncInfo_internal *);
void NSRemoveSyncInfo(NSSyncInfo_internal *);
(void) handle;
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(clientResponse, OC_STACK_KEEP_TRANSACTION,
- NSRemoveProvider((NSProvider_internal *) ctx));
+ NSRemoveProvider_internal((NSProvider_internal *) ctx));
NS_VERIFY_STACK_SUCCESS_WITH_POST_CLEANING(NSOCResultToSuccess(clientResponse->result),
- OC_STACK_KEEP_TRANSACTION, NSRemoveProvider((NSProvider_internal *) ctx));
+ OC_STACK_KEEP_TRANSACTION, NSRemoveProvider_internal((NSProvider_internal *) ctx));
NS_LOG_V(DEBUG, "GET response income : %s:%d",
clientResponse->devAddr.addr, clientResponse->devAddr.port);
NSTopicLL * newTopicLL = NSGetTopicLL(clientResponse);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicLL, OC_STACK_KEEP_TRANSACTION,
- NSRemoveProvider((NSProvider_internal *) ctx));
+ NSRemoveProvider_internal((NSProvider_internal *) ctx));
NSProvider_internal * provider = (NSProvider_internal *) ctx;
provider->topicLL = NSCopyTopicLL(newTopicLL);
NS_LOG(DEBUG, "build NSTask");
NSTask * task = NSMakeTask(TASK_CONSUMER_RECV_TOPIC_LIST, (void *) provider);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProvider(provider));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProvider_internal(provider));
NSConsumerPushEvent(task);
NSRemoveTopicLL(newTopicLL);
NS_LOG(DEBUG, "build NSTask");
NSTask * task = NSMakeTask(TASK_CONSUMER_PROVIDER_DISCOVERED, (void *) newProvider);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProvider(newProvider));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProvider_internal(newProvider));
NSConsumerPushEvent(task);
NS_VERIFY_NOT_NULL(providerId, NULL);
- return (NSProvider *) NSConsumerFindNSProvider(providerId);
+ NSProvider_internal * prov = NSConsumerFindNSProvider(providerId);
+ NS_VERIFY_NOT_NULL(prov, NULL);
+
+ NSProvider * retProv = NSCopyProvider(prov);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(retProv, NULL, NSRemoveProvider_internal(prov));
+ NSRemoveProvider_internal(prov);
+
+ return retProv;
}
NSMessage * NSConsumerGetMessage(uint64_t messageId)
NS_VERIFY_NOT_NULL(provider, NS_ERROR);
- NSSelector selector = (NSSelector)((NSProvider_internal *) provider)->accessPolicy;
+ NSProvider_internal * prov = NSConsumerFindNSProvider(provider->providerId);
+ NS_VERIFY_NOT_NULL(prov, NS_ERROR);
+ NSSelector selector = prov->accessPolicy;
+ NSRemoveProvider_internal(prov);
+
NS_VERIFY_NOT_NULL(selector == NS_SELECTION_CONSUMER ? (void *) 1 : NULL, NS_ERROR);
NSTask * topicTask = NSMakeTask(TASK_CONSUMER_GET_TOPIC_LIST, (void *) provider);
NS_VERIFY_NOT_NULL(isStartedConsumer == true ? (void *) 1 : NULL, NS_ERROR);
NS_VERIFY_NOT_NULL(provider, NS_ERROR);
-
- NSSelector selector = (NSSelector)((NSProvider_internal *) provider)->accessPolicy;
- NS_VERIFY_NOT_NULL(selector == NS_SELECTION_CONSUMER ? (void *) 1 : NULL, NS_ERROR);
-
- if (!provider->topicLL)
- {
- provider->topicLL = (NSTopicLL *) OICMalloc(sizeof(NSTopicLL));
- }
NS_VERIFY_NOT_NULL(provider->topicLL, NS_ERROR);
+ NSProvider_internal * prov = NSConsumerFindNSProvider(provider->providerId);
+ NS_VERIFY_NOT_NULL(prov, NS_ERROR);
+
+ NSSelector selector = prov->accessPolicy;
+ NSRemoveProvider_internal(prov);
+ NS_VERIFY_NOT_NULL(selector == NS_SELECTION_CONSUMER ? (void *) 1 : NULL, NS_ERROR);
NSTask * topicTask = NSMakeTask(TASK_CONSUMER_SELECT_TOPIC_LIST, (void *) provider);
NS_VERIFY_NOT_NULL(provider, NS_ERROR);
NSCacheElement * cacheElement = NSStorageRead(ProviderCache, providerId);
NS_VERIFY_NOT_NULL(cacheElement, NULL);
- return NSCopyProvider((NSProvider_internal *) cacheElement->data);
+ return NSCopyProvider_internal((NSProvider_internal *) cacheElement->data);
}
void NSRemoveCacheElementMessage(NSCacheElement * obj)
if (provider->accessPolicy == NS_SELECTION_CONSUMER && isSubscribing == false)
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
- NSDiscoveredProvider((NSProvider *) provider);
+ NSProvider * providerForCb = NSCopyProvider(provider);
+ NSDiscoveredProvider(providerForCb);
}
else
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
- NSProvider_internal * subProvider = NSCopyProvider(provider);
+ NSProvider_internal * subProvider = NSCopyProvider_internal(provider);
NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) subProvider);
NS_VERIFY_NOT_NULL_V(task);
NSConsumerPushEvent(task);
}
- NSRemoveProvider(providerCacheData);
+ NSRemoveProvider_internal(providerCacheData);
}
void NSConsumerHandleProviderDeleted(NSProvider_internal * provider)
NS_VERIFY_NOT_NULL_V(provider);
NSTask * topicTask = NSMakeTask(TASK_CONSUMER_REQ_TOPIC_LIST, (void *) provider);
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(topicTask, NSRemoveProvider(provider));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(topicTask, NSRemoveProvider_internal(provider));
NSConsumerPushEvent(topicTask);
}
{
NS_LOG(DEBUG, "Receive New Provider is discovered.");
NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
- NSRemoveProvider((NSProvider_internal *)task->taskData);
+ NSRemoveProvider_internal((NSProvider_internal *)task->taskData);
break;
}
case TASK_RECV_SYNCINFO:
{
NS_LOG(DEBUG, "Receive Topic List");
NSConsumerHandleRecvTopicLL((NSProvider_internal *)task->taskData);
- NSRemoveProvider((NSProvider_internal *)task->taskData);
+ NSRemoveProvider_internal((NSProvider_internal *)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);
+ NSRemoveProvider_internal((NSProvider_internal *)task->taskData);
break;
}
default :
}
else if (type == NS_CONSUMER_CACHE_PROVIDER)
{
- NSRemoveProvider((NSProvider_internal *) del->data);
+ NSRemoveProvider_internal((NSProvider_internal *) del->data);
}
NSOICFree(del);
pthread_mutex_unlock(mutex);
}
else if (type == NS_CONSUMER_CACHE_PROVIDER)
{
- NSRemoveProvider((NSProvider_internal *) del->data);
+ NSRemoveProvider_internal((NSProvider_internal *) del->data);
}
NSOICFree(del);
pthread_mutex_unlock(mutex);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(obj, NS_ERROR, pthread_mutex_unlock(mutex));
NS_LOG_V(DEBUG, "New Object address : %s:%d", newProvObj->connection->addr->addr, newProvObj->connection->addr->port);
- obj->data = (void *) NSCopyProvider(newProvObj);
+ obj->data = (void *) NSCopyProvider_internal(newProvObj);
NS_LOG (DEBUG, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!2");
prov = (NSProvider_internal *)obj->data;
{
next = (NSCacheElement *) iter->next;
- NSRemoveProvider((NSProvider_internal *) iter->data);
+ NSRemoveProvider_internal((NSProvider_internal *) iter->data);
NSOICFree(iter);
iter = next;
break;
}
case TASK_CONSUMER_REQ_SUBSCRIBE:
+ {
+ NSProvider_internal * prov =
+ NSConsumerFindNSProvider(((NSProvider *)task->taskData)->providerId);
+ NS_VERIFY_NOT_NULL_V(prov);
+ NSTask * subTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, prov);
+ NS_VERIFY_NOT_NULL_V(subTask);
+ NSConsumerCommunicationTaskProcessing(subTask);
+
+ NSRemoveProvider((NSProvider *)task->taskData);
+ NSOICFree(task);
+ break;
+ }
case TASK_SEND_SYNCINFO:
case TASK_CONSUMER_REQ_TOPIC_LIST:
+ {
+ NSConsumerCommunicationTaskProcessing(task);
+ break;
+ }
case TASK_CONSUMER_GET_TOPIC_LIST:
case TASK_CONSUMER_SELECT_TOPIC_LIST:
{
- NSConsumerCommunicationTaskProcessing(task);
+ NSProvider_internal * prov =
+ NSConsumerFindNSProvider(((NSProvider *)task->taskData)->providerId);
+ NS_VERIFY_NOT_NULL_V(prov);
+ NSTask * topTask = NSMakeTask(task->taskType, prov);
+ NS_VERIFY_NOT_NULL_V(topTask);
+ NSConsumerCommunicationTaskProcessing(topTask);
+
+ NSRemoveProvider((NSProvider *)task->taskData);
+ NSOICFree(task);
break;
}
case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
{
- NSProvider_internal * data = NSCopyProvider((NSProvider_internal *)task->taskData);
+ NSProvider_internal * data =
+ NSConsumerFindNSProvider(((NSProvider *)task->taskData)->providerId);
NS_VERIFY_NOT_NULL_V(data);
NSTask * conTask = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, data);
NS_VERIFY_NOT_NULL_V(conTask);
- NSConsumerCommunicationTaskProcessing(task);
- NSConsumerInternalTaskProcessing(conTask);
+ NSConsumerCommunicationTaskProcessing(conTask);
+
+ data = NSConsumerFindNSProvider(((NSProvider *)task->taskData)->providerId);
+ NS_VERIFY_NOT_NULL_V(data);
+ NSTask * conTask2 = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, data);
+ NSConsumerInternalTaskProcessing(conTask2);
+
+ NSRemoveProvider((NSProvider *)task->taskData);
+ NSOICFree(task);
break;
}
case TASK_RECV_SYNCINFO: