} NSMessageStateList;
// Mutex of MessageState storage
-pthread_mutex_t * NSGetMessageListMutex();
+pthread_mutex_t ** NSGetMessageListMutex();
void NSLockMessageListMutex();
void NSUnlockMessageListMutex();
*(NSGetProviderCacheList()) = cache;
}
-void NSDestroyProviderCacheList()
+void NSDestroyInternalCachedList()
{
NSCacheList * cache = *(NSGetProviderCacheList());
if (cache)
{
- NSStorageDestroy(cache);
+ NSConsumerStorageDestroy(cache);
}
NSSetProviderCacheList(NULL);
+
+ NSDestroyMessageStateList();
+ pthread_mutex_destroy(*NSGetMessageListMutex());
+ NSOICFree(*NSGetMessageListMutex());
}
NSProvider_internal * NSProviderCacheFind(const char * providerId)
if (!ProviderCache)
{
NS_LOG(DEBUG, "Provider Cache Init");
- ProviderCache = NSStorageCreate();
+ ProviderCache = NSConsumerStorageCreate();
NS_VERIFY_NOT_NULL(ProviderCache, NULL);
ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
NSSetProviderCacheList(ProviderCache);
}
- NSCacheElement * cacheElement = NSStorageRead(ProviderCache, providerId);
+ NSCacheElement * cacheElement = NSConsumerStorageRead(ProviderCache, providerId);
NS_VERIFY_NOT_NULL(cacheElement, NULL);
return NSCopyProvider_internal((NSProvider_internal *) cacheElement->data);
if (!ProviderCache)
{
NS_LOG(DEBUG, "Provider Cache Init");
- ProviderCache = NSStorageCreate();
+ ProviderCache = NSConsumerStorageCreate();
NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
obj->next = NULL;
NS_LOG(DEBUG, "try to write to storage");
- NSResult ret = NSStorageWrite(ProviderCache, obj);
+ NSResult ret = NSConsumerStorageWrite(ProviderCache, obj);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
NS_ERROR, NSOICFree(obj));
+ NSOICFree(obj);
+
return NS_OK;
}
if (!ProviderCache)
{
NS_LOG(DEBUG, "Provider Cache Init");
- ProviderCache = NSStorageCreate();
+ ProviderCache = NSConsumerStorageCreate();
NS_VERIFY_NOT_NULL_V(ProviderCache);
ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
NSSetProviderCacheList(ProviderCache);
}
- NSCacheElement * obj = NULL;
- while ((obj = NSPopProviderCacheList(ProviderCache)))
+ NSCacheElement * obj = NSPopProviderCacheList(ProviderCache);
+ while (obj)
{
NS_LOG(DEBUG, "build NSTask");
NSProvider * prov = NSCopyProvider((NSProvider_internal *) obj->data);
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(prov,
- NSRemoveProvider_internal((NSProvider_internal *) obj->data));
+ NSRemoveProvider_internal((void *) obj->data));
NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, prov);
NS_VERIFY_NOT_NULL_V(task);
NSConsumerPushEvent(task);
+ NSRemoveProvider_internal((void *) obj->data);
+ NSOICFree(obj);
+
+ obj = NSPopProviderCacheList(ProviderCache);
}
}
isSubscribing |= infos->isSubscribing;
if (infos->addr->adapter == newAdapter && infos->isSubscribing == true)
{
- NS_LOG_V(DEBUG, "This provider already discovered : %s:%d",
+ NS_LOG_V(INFO_PRIVATE, "This provider already discovered : %s:%d",
infos->addr->addr, infos->addr->port);
NS_LOG_V(DEBUG, "Subscription : %d", infos->isSubscribing);
return;
}
NSResult ret = NSProviderCacheUpdate(provider);
- NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(ret == NS_OK ? (void *) 1 : NULL,
+ NSRemoveProvider_internal(providerCacheData));
if (isAdded == false)
{
if (provider->accessPolicy == NS_SELECTION_CONSUMER && isSubscribing == false)
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
- NSProvider * providerForCb = NSCopyProvider(provider);
- NSProviderChanged(providerForCb, NS_DISCOVERED);
- NSRemoveProvider(providerForCb);
+ NSProvider * prov = NSCopyProvider(provider);
+ NSProviderChanged(prov, NS_DISCOVERED);
+ NSRemoveProvider(prov);
}
else
{
NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
- NSProvider_internal * subProvider = NSCopyProvider_internal(provider);
+ NSProvider * subProvider = NSCopyProvider(provider);
NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) subProvider);
- NS_VERIFY_NOT_NULL_V(task);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(task,
+ NSRemoveProvider_internal(providerCacheData));
NSConsumerPushEvent(task);
}
NSCacheList * providerCache = *(NSGetProviderCacheList());
NS_VERIFY_NOT_NULL_V(providerCache);
- NSResult ret = NSStorageDelete(providerCache, provider->providerId);
+ NSResult ret = NSConsumerStorageDelete(providerCache, provider->providerId);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
- NS_LOG_V(DEBUG, "Stopped Provider : %s", provider->providerId);
- NSProvider * providerForCb = NSCopyProvider(provider);
- NSProviderChanged(providerForCb, NS_STOPPED);
+ NS_LOG_V(INFO_PRIVATE, "Stopped Provider : %s", provider->providerId);
+ NSProvider * prov = NSCopyProvider(provider);
+ NSProviderChanged(prov, NS_STOPPED);
+ NSRemoveProvider(prov);
}
void NSConsumerHandleSubscribeSucceed(NSProvider_internal * provider)
NSCacheList * ProviderCache = *(NSGetProviderCacheList());
- NSCacheElement * cacheElement = NSStorageRead(ProviderCache, provider->providerId);
+ NSCacheElement * cacheElement = NSConsumerStorageRead(ProviderCache, provider->providerId);
NS_VERIFY_NOT_NULL_V(cacheElement);
pthread_mutex_t * mutex = NSGetCacheMutex();
{
NS_VERIFY_NOT_NULL_V(msg);
- NS_LOG_V(DEBUG, "confirmed by : %s", msg->providerId);
+ NS_LOG_V(INFO_PRIVATE, "confirmed by : %s", msg->providerId);
NSCacheList * ProviderCache = *(NSGetProviderCacheList());
- NSCacheElement * cacheElement = NSStorageRead(ProviderCache, msg->providerId);
+ NSCacheElement * cacheElement = NSConsumerStorageRead(ProviderCache, msg->providerId);
NS_VERIFY_NOT_NULL_V(cacheElement);
pthread_mutex_t * mutex = NSGetCacheMutex();
pthread_mutex_unlock(mutex);
NSProviderChanged(prov, (NSProviderState) msg->messageId);
+ NSRemoveProvider(prov);
}
void NSConsumerHandleRecvMessage(NSMessage * msg)
NS_VERIFY_NOT_NULL_V (provider);
NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection);
- NSRemoveProvider_internal(provider);
+ NSRemoveProvider_internal((void *) provider);
NS_VERIFY_NOT_NULL_V (connections);
NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
NSRemoveConnections(provider->connection);
provider->connection = NULL;
+ NSProvider_internal * cachedProvider = NSProviderCacheFind(provider->providerId);
+ NS_VERIFY_NOT_NULL_V(cachedProvider);
+
+ if (!cachedProvider->topicLL && !provider->topicLL)
+ {
+ NS_LOG(DEBUG, "topic is null and previous status is same.");
+ NSRemoveProvider_internal(cachedProvider);
+ return;
+ }
+ NSRemoveProvider_internal(cachedProvider);
+
NSResult ret = NSProviderCacheUpdate(provider);
NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
NS_LOG(DEBUG, "call back to user");
NSProvider * prov = NSCopyProvider(provider);
NSProviderChanged((NSProvider *) prov, (NSProviderState) NS_TOPIC);
+ NSRemoveProvider(prov);
}
void NSConsumerInternalTaskProcessing(NSTask * task)
{
NS_LOG(DEBUG, "Receive Subscribe succeed from provider.");
NSConsumerHandleSubscribeSucceed((NSProvider_internal *)task->taskData);
- NSRemoveProvider_internal((NSProvider_internal *)task->taskData);
+ NSRemoveProvider_internal((void *)task->taskData);
break;
}
case TASK_CONSUMER_RECV_PROVIDER_CHANGED:
}
// implements of MessageState function
-pthread_mutex_t * NSGetMessageListMutex()
+pthread_mutex_t ** NSGetMessageListMutex()
{
static pthread_mutex_t * g_mutex = NULL;
if (g_mutex == NULL)
pthread_mutex_init(g_mutex, NULL);
}
- return g_mutex;
+ return & g_mutex;
}
void NSLockMessageListMutex()
{
NS_LOG_V(DEBUG, "%s", __func__);
- pthread_mutex_lock(NSGetMessageListMutex());
+ pthread_mutex_lock(*NSGetMessageListMutex());
}
void NSUnlockMessageListMutex()
{
NS_LOG_V(DEBUG, "%s", __func__);
- pthread_mutex_unlock(NSGetMessageListMutex());
+ pthread_mutex_unlock(*NSGetMessageListMutex());
}
-NSMessageStateList * NSGetMessageStateList()
+NSMessageStateList ** NSGetMessageStateListAddr()
{
static NSMessageStateList * g_messageStateList = NULL;
if (g_messageStateList == NULL)
g_messageStateList->tail = NULL;
}
- return g_messageStateList;
+ return & g_messageStateList;
+}
+
+NSMessageStateList * NSGetMessageStateList()
+{
+ return * NSGetMessageStateListAddr();
}
NSMessageStateLL * NSFindMessageState(uint64_t msgId)
{
NS_LOG_V(DEBUG, "%s", __func__);
- if (msgId <= NS_RESERVED_MESSAGEID) return NULL;
+ if (msgId <= NS_RESERVED_MESSAGEID)
+ {
+ return NULL;
+ }
NSMessageStateLL * iter = NULL;
NSLockMessageListMutex();
+ if (NSGetMessageStateList()->head == NULL)
+ {
+ NSUnlockMessageListMutex();
+ return NULL;
+ }
+
for (iter = NSGetMessageStateList()->head; iter; iter = iter->next)
{
if (iter->messageId == msgId)
bool NSUpdateMessageState(uint64_t msgId, NSSyncType state)
{
NS_LOG_V(DEBUG, "%s", __func__);
- if (msgId <= NS_RESERVED_MESSAGEID) return NULL;
+ if (msgId <= NS_RESERVED_MESSAGEID)
+ {
+ return false;
+ }
NSMessageStateLL * iter = NULL;
NSLockMessageListMutex();
bool NSDeleteMessageState(uint64_t msgId)
{
NS_LOG_V(DEBUG, "%s", __func__);
- if (msgId <= NS_RESERVED_MESSAGEID) return NULL;
+ if (msgId <= NS_RESERVED_MESSAGEID)
+ {
+ return false;
+ }
+
NSMessageStateLL * iter = NULL;
NSMessageStateLL * prev = NULL;
NSOICFree(del);
}
+ NSGetMessageStateList()->head = NULL;
+ NSGetMessageStateList()->tail = NULL;
+
NSUnlockMessageListMutex();
+
+ pthread_mutex_t * mu = *NSGetMessageListMutex();
+ pthread_mutex_destroy(mu);
+ NSOICFree(mu);
+ *NSGetMessageListMutex() = NULL;
+
+ NSMessageStateList * list = NSGetMessageStateList();
+ NSOICFree(list);
+ *NSGetMessageStateListAddr() = NULL;
}