1 //******************************************************************
3 // Copyright 2016 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
11 // http://www.apache.org/licenses/LICENSE-2.0
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "NSConstants.h"
22 #include "NSConsumerCommon.h"
23 #include "NSConsumerInternalTaskController.h"
24 #include "NSStructs.h"
26 #include "oic_malloc.h"
27 #include "oic_string.h"
29 #define NS_RESERVED_MESSAGEID 10
31 // MessageState storage structure
32 typedef struct _NSMessageStateLL
36 struct _NSMessageStateLL * next;
42 NSMessageStateLL * head;
43 NSMessageStateLL * tail;
47 // Mutex of MessageState storage
48 pthread_mutex_t ** NSGetMessageListMutex();
49 void NSLockMessageListMutex();
50 void NSUnlockMessageListMutex();
52 // Function for MessageState
53 NSMessageStateList * NSGetMessageStateList();
54 NSMessageStateLL * NSFindMessageState(uint64_t msgId);
55 bool NSUpdateMessageState(uint64_t msgId, NSSyncType state);
56 bool NSDeleteMessageState(uint64_t msgId);
57 bool NSInsertMessageState(uint64_t msgId, NSSyncType state);
58 void NSDestroyMessageStateList();
60 NSCacheList ** NSGetProviderCacheList()
62 static NSCacheList * providerCache = NULL;
63 return & providerCache;
66 void NSSetProviderCacheList(NSCacheList * cache)
68 *(NSGetProviderCacheList()) = cache;
71 void NSDestroyInternalCachedList()
73 NSCacheList * cache = *(NSGetProviderCacheList());
76 NSConsumerStorageDestroy(cache);
79 NSSetProviderCacheList(NULL);
81 NSDestroyMessageStateList();
82 pthread_mutex_destroy(*NSGetMessageListMutex());
83 NSOICFree(*NSGetMessageListMutex());
86 NSProvider_internal * NSProviderCacheFind(const char * providerId)
88 NS_VERIFY_NOT_NULL(providerId, NULL);
90 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
93 NS_LOG(DEBUG, "Provider Cache Init");
94 ProviderCache = NSConsumerStorageCreate();
95 NS_VERIFY_NOT_NULL(ProviderCache, NULL);
97 ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
98 NSSetProviderCacheList(ProviderCache);
101 NSCacheElement * cacheElement = NSConsumerStorageRead(ProviderCache, providerId);
102 NS_VERIFY_NOT_NULL(cacheElement, NULL);
104 return NSCopyProvider_internal((NSProvider_internal *) cacheElement->data);
107 NSProvider_internal * NSFindProviderFromAddr(OCDevAddr * addr)
109 NS_VERIFY_NOT_NULL(addr, NULL);
111 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
114 NS_LOG(DEBUG, "Provider Cache does not intialized.");
118 NSCacheElement * cacheElement =
119 NSGetProviderFromAddr(ProviderCache, addr->addr, addr->port);
121 NS_VERIFY_NOT_NULL(cacheElement, NULL);
123 return NSCopyProvider_internal((NSProvider_internal *) cacheElement->data);
126 NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
128 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
131 NS_LOG(DEBUG, "Provider Cache Init");
132 ProviderCache = NSConsumerStorageCreate();
133 NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
135 ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
136 NSSetProviderCacheList(ProviderCache);
139 NS_VERIFY_NOT_NULL(provider, NS_ERROR);
141 NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
142 NS_VERIFY_NOT_NULL(obj, NS_ERROR);
144 obj->data = (NSCacheData *) provider;
147 NS_LOG(DEBUG, "try to write to storage");
148 NSResult ret = NSConsumerStorageWrite(ProviderCache, obj);
149 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
150 NS_ERROR, NSOICFree(obj));
157 void NSCancelAllSubscription()
159 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
162 NS_LOG(DEBUG, "Provider Cache Init");
163 ProviderCache = NSConsumerStorageCreate();
164 NS_VERIFY_NOT_NULL_V(ProviderCache);
166 ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
167 NSSetProviderCacheList(ProviderCache);
170 NSCacheElement * obj = NSPopProviderCacheList(ProviderCache);
173 NS_LOG(DEBUG, "build NSTask");
174 NSProvider * prov = NSCopyProvider((NSProvider_internal *) obj->data);
175 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(prov,
176 NSRemoveProvider_internal((void *) obj->data));
178 NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL, prov);
179 NS_VERIFY_NOT_NULL_V(task);
181 NSConsumerPushEvent(task);
182 NSRemoveProvider_internal((void *) obj->data);
185 obj = NSPopProviderCacheList(ProviderCache);
189 void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
191 NS_VERIFY_NOT_NULL_V(provider);
194 bool isSubscribing = false;
196 NSProvider_internal * providerCacheDataFromAddr
197 = NSFindProviderFromAddr(provider->connection->addr);
199 if (providerCacheDataFromAddr)
201 if (!strcmp(providerCacheDataFromAddr->providerId, provider->providerId))
203 NSProviderConnectionInfo * infos = providerCacheDataFromAddr->connection;
206 isSubscribing |= infos->isSubscribing;
210 if (isSubscribing == false)
212 NSProvider * providerForCb = NSCopyProvider(providerCacheDataFromAddr);
213 NSProviderChanged(providerForCb, NS_DISCOVERED);
214 NSRemoveProvider(providerForCb);
216 NSRemoveProvider_internal(providerCacheDataFromAddr);
219 NSRemoveProvider_internal(providerCacheDataFromAddr);
222 NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
224 if (providerCacheData == NULL)
230 providerCacheData->accessPolicy = provider->accessPolicy;
231 NSProviderConnectionInfo * infos = providerCacheData->connection;
232 OCTransportAdapter newAdapter = provider->connection->addr->adapter;
235 isSubscribing |= infos->isSubscribing;
236 if (infos->addr->adapter == newAdapter && infos->isSubscribing == true)
238 NS_LOG_V(INFO_PRIVATE, "This provider already discovered : %s:%d",
239 infos->addr->addr, infos->addr->port);
240 NS_LOG_V(DEBUG, "Subscription : %d", infos->isSubscribing);
247 NSResult ret = NSProviderCacheUpdate(provider);
248 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(ret == NS_OK ? (void *) 1 : NULL,
249 NSRemoveProvider_internal(providerCacheData));
251 if (isAdded == false)
253 NS_LOG(DEBUG, "New provider is discovered");
257 provider = providerCacheData;
258 NS_LOG(DEBUG, "provider's connection is updated.");
261 if (provider->accessPolicy == NS_SELECTION_CONSUMER && isSubscribing == false)
263 NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
264 NSProvider * prov = NSCopyProvider(provider);
265 NSProviderChanged(prov, NS_DISCOVERED);
266 NSRemoveProvider(prov);
270 NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
271 NSProvider * subProvider = NSCopyProvider(provider);
272 NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) subProvider);
273 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(task,
274 NSRemoveProvider_internal(providerCacheData));
276 NSConsumerPushEvent(task);
279 NSRemoveProvider_internal(providerCacheData);
282 void NSConsumerHandleProviderDeleted(NSProvider_internal * provider)
284 NS_VERIFY_NOT_NULL_V(provider);
286 NSCacheList * providerCache = *(NSGetProviderCacheList());
287 NS_VERIFY_NOT_NULL_V(providerCache);
289 NSResult ret = NSConsumerStorageDelete(providerCache, provider->providerId);
290 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
292 NS_LOG_V(INFO_PRIVATE, "Stopped Provider : %s", provider->providerId);
293 NSProvider * prov = NSCopyProvider(provider);
294 NSProviderChanged(prov, NS_STOPPED);
295 NSRemoveProvider(prov);
298 void NSConsumerHandleSubscribeSucceed(NSProvider_internal * provider)
300 NS_VERIFY_NOT_NULL_V(provider);
302 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
304 NSCacheElement * cacheElement = NSConsumerStorageRead(ProviderCache, provider->providerId);
305 NS_VERIFY_NOT_NULL_V(cacheElement);
307 pthread_mutex_t * mutex = NSGetCacheMutex();
308 pthread_mutex_lock(mutex);
310 NS_VERIFY_NOT_NULL_V(cacheElement);
311 NSProvider_internal * prov = (NSProvider_internal *)cacheElement->data;
312 NSProviderConnectionInfo *infos = prov->connection;
315 infos->isSubscribing = true;
319 pthread_mutex_unlock(mutex);
322 void NSConsumerHandleRecvProviderChanged(NSMessage * msg)
324 NS_VERIFY_NOT_NULL_V(msg);
326 NS_LOG_V(INFO_PRIVATE, "confirmed by : %s", msg->providerId);
328 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
330 NSCacheElement * cacheElement = NSConsumerStorageRead(ProviderCache, msg->providerId);
331 NS_VERIFY_NOT_NULL_V(cacheElement);
333 pthread_mutex_t * mutex = NSGetCacheMutex();
334 pthread_mutex_lock(mutex);
335 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(cacheElement, pthread_mutex_unlock(mutex));
336 NSProvider_internal * provider = (NSProvider_internal *) cacheElement->data;
337 if (provider->state == (NSProviderState) msg->messageId)
339 NS_LOG_V(DEBUG, "Already receive message(ALLOW/DENY) : %d", (int) msg->messageId);
340 pthread_mutex_unlock(mutex);
344 NS_LOG_V(DEBUG, "Provider State Changed %d -> %d",
345 (int) provider->state, (int) msg->messageId);
346 NS_LOG(DEBUG, "call back to user");
347 provider->state = (NSProviderState) msg->messageId;
349 NSProvider * prov = NSCopyProvider(provider);
351 pthread_mutex_unlock(mutex);
352 NSProviderChanged(prov, (NSProviderState) msg->messageId);
353 NSRemoveProvider(prov);
356 void NSConsumerHandleRecvMessage(NSMessage * msg)
358 NS_VERIFY_NOT_NULL_V(msg);
360 if (NSInsertMessageState(msg->messageId, NS_SYNC_UNREAD))
366 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
368 NS_VERIFY_NOT_NULL_V(sync);
370 if (NSUpdateMessageState(sync->messageId, sync->state))
372 NSNotificationSync(sync);
375 if (sync->state == NS_SYNC_DELETED)
377 NSDeleteMessageState(sync->messageId);
381 void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
383 NS_VERIFY_NOT_NULL_V(sync);
385 NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
386 NS_VERIFY_NOT_NULL_V (provider);
388 NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection);
389 NSRemoveProvider_internal((void *) provider);
390 NS_VERIFY_NOT_NULL_V (connections);
392 NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
393 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo, NSRemoveConnections(connections));
395 OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
396 syncInfo->messageId = sync->messageId;
397 syncInfo->state = sync->state;
398 syncInfo->connection = connections;
400 NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
401 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
403 NSConsumerPushEvent(syncTask);
406 void NSConsumerHandleGetTopicUri(NSMessage * msg)
408 NS_VERIFY_NOT_NULL_V(msg);
410 NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
411 NS_VERIFY_NOT_NULL_V(provider);
413 NSTask * topicTask = NSMakeTask(TASK_CONSUMER_REQ_TOPIC_LIST, (void *) provider);
414 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(topicTask, NSRemoveProvider_internal(provider));
416 NSConsumerPushEvent(topicTask);
419 void NSConsumerHandleRecvTopicLL(NSProvider_internal * provider)
421 NS_VERIFY_NOT_NULL_V(provider);
423 NSRemoveConnections(provider->connection);
424 provider->connection = NULL;
426 NSProvider_internal * cachedProvider = NSProviderCacheFind(provider->providerId);
427 NS_VERIFY_NOT_NULL_V(cachedProvider);
429 if (!cachedProvider->topicLL && !provider->topicLL)
431 NS_LOG(DEBUG, "topic is null and previous status is same.");
432 NSRemoveProvider_internal(cachedProvider);
435 NSRemoveProvider_internal(cachedProvider);
437 NSResult ret = NSProviderCacheUpdate(provider);
438 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
440 NS_LOG(DEBUG, "call back to user");
441 NSProvider * prov = NSCopyProvider(provider);
442 NSProviderChanged((NSProvider *) prov, (NSProviderState) NS_TOPIC);
443 NSRemoveProvider(prov);
446 void NSConsumerInternalTaskProcessing(NSTask * task)
448 NS_VERIFY_NOT_NULL_V(task);
450 NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
451 switch (task->taskType)
453 case TASK_CONSUMER_SENT_REQ_OBSERVE:
455 NS_LOG(DEBUG, "Receive Subscribe succeed from provider.");
456 NSConsumerHandleSubscribeSucceed((NSProvider_internal *)task->taskData);
457 NSRemoveProvider_internal((void *)task->taskData);
460 case TASK_CONSUMER_RECV_PROVIDER_CHANGED:
462 NS_LOG(DEBUG, "Receive Provider Changed");
463 NSConsumerHandleRecvProviderChanged((NSMessage *)task->taskData);
464 NSRemoveMessage((NSMessage *)task->taskData);
467 case TASK_CONSUMER_RECV_MESSAGE:
469 NS_LOG(DEBUG, "Receive New Notification");
470 NSConsumerHandleRecvMessage((NSMessage *)task->taskData);
471 NSRemoveMessage((NSMessage *)task->taskData);
474 case TASK_CONSUMER_PROVIDER_DISCOVERED:
476 NS_LOG(DEBUG, "Receive New Provider is discovered.");
477 NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
478 NSRemoveProvider_internal((NSProvider_internal *)task->taskData);
481 case TASK_RECV_SYNCINFO:
483 NS_LOG(DEBUG, "Receive SyncInfo.");
484 NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
485 NSOICFree(task->taskData);
488 case TASK_MAKE_SYNCINFO:
490 NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
491 NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
492 NSOICFree(task->taskData);
495 case TASK_CONSUMER_REQ_TOPIC_URI:
497 NS_LOG(DEBUG, "Request Topic Uri");
498 NSConsumerHandleGetTopicUri((NSMessage *)task->taskData);
499 NSRemoveMessage((NSMessage *)task->taskData);
502 case TASK_CONSUMER_RECV_TOPIC_LIST:
504 NS_LOG(DEBUG, "Receive Topic List");
505 NSConsumerHandleRecvTopicLL((NSProvider_internal *)task->taskData);
506 NSRemoveProvider_internal((NSProvider_internal *)task->taskData);
509 case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
511 NS_LOG(DEBUG, "Make Subscribe cancel from provider.");
512 NSConsumerHandleProviderDeleted((NSProvider_internal *)task->taskData);
513 NSRemoveProvider_internal((NSProvider_internal *)task->taskData);
518 NS_LOG(ERROR, "Unknown TASK Type");
525 // implements of MessageState function
526 pthread_mutex_t ** NSGetMessageListMutex()
528 static pthread_mutex_t * g_mutex = NULL;
531 g_mutex = (pthread_mutex_t *) OICMalloc(sizeof(pthread_mutex_t));
532 NS_VERIFY_NOT_NULL(g_mutex, NULL);
534 pthread_mutex_init(g_mutex, NULL);
539 void NSLockMessageListMutex()
541 NS_LOG_V(DEBUG, "%s", __func__);
542 pthread_mutex_lock(*NSGetMessageListMutex());
545 void NSUnlockMessageListMutex()
547 NS_LOG_V(DEBUG, "%s", __func__);
548 pthread_mutex_unlock(*NSGetMessageListMutex());
551 NSMessageStateList ** NSGetMessageStateListAddr()
553 static NSMessageStateList * g_messageStateList = NULL;
554 if (g_messageStateList == NULL)
556 g_messageStateList = (NSMessageStateList *)OICMalloc(sizeof(NSMessageStateList));
557 NS_VERIFY_NOT_NULL(g_messageStateList, NULL);
559 g_messageStateList->head = NULL;
560 g_messageStateList->tail = NULL;
563 return & g_messageStateList;
566 NSMessageStateList * NSGetMessageStateList()
568 return * NSGetMessageStateListAddr();
571 NSMessageStateLL * NSFindMessageState(uint64_t msgId)
573 NS_LOG_V(DEBUG, "%s", __func__);
574 if (msgId <= NS_RESERVED_MESSAGEID)
578 NSMessageStateLL * iter = NULL;
580 NSLockMessageListMutex();
581 if (NSGetMessageStateList()->head == NULL)
583 NSUnlockMessageListMutex();
587 for (iter = NSGetMessageStateList()->head; iter; iter = iter->next)
589 if (iter->messageId == msgId)
591 NSUnlockMessageListMutex();
596 NSUnlockMessageListMutex();
600 bool NSUpdateMessageState(uint64_t msgId, NSSyncType state)
602 NS_LOG_V(DEBUG, "%s", __func__);
603 if (msgId <= NS_RESERVED_MESSAGEID)
607 NSMessageStateLL * iter = NULL;
609 NSLockMessageListMutex();
610 for (iter = NSGetMessageStateList()->head; iter; iter = iter->next)
612 if (iter->messageId == msgId && state != iter->state)
615 NSUnlockMessageListMutex();
620 NSUnlockMessageListMutex();
624 bool NSDeleteMessageState(uint64_t msgId)
626 NS_LOG_V(DEBUG, "%s", __func__);
627 if (msgId <= NS_RESERVED_MESSAGEID)
632 NSMessageStateLL * iter = NULL;
633 NSMessageStateLL * prev = NULL;
635 NSLockMessageListMutex();
636 for (iter = NSGetMessageStateList()->head; iter; iter = iter->next)
638 if (iter->messageId == msgId)
640 if (iter == NSGetMessageStateList()->head)
642 NSGetMessageStateList()->head = NULL;
643 NSGetMessageStateList()->tail = NULL;
645 else if (iter == NSGetMessageStateList()->tail)
648 NSGetMessageStateList()->tail = prev;
652 prev->next = iter->next;
654 NSUnlockMessageListMutex();
662 NSUnlockMessageListMutex();
666 bool NSInsertMessageState(uint64_t msgId, NSSyncType state)
668 NS_LOG_V(DEBUG, "%s", __func__);
669 if (NSFindMessageState(msgId))
674 NSMessageStateLL * insertMsg = (NSMessageStateLL * )OICMalloc(sizeof(NSMessageStateLL));
675 NS_VERIFY_NOT_NULL(insertMsg, false);
677 insertMsg->messageId = msgId;
678 insertMsg->state = state;
679 insertMsg->next = NULL;
681 NSLockMessageListMutex();
682 if (NSGetMessageStateList()->head == NULL)
684 NSGetMessageStateList()->head = insertMsg;
688 NSGetMessageStateList()->tail->next = insertMsg;
690 NSGetMessageStateList()->tail = insertMsg;
691 NSUnlockMessageListMutex();
696 void NSDestroyMessageStateList()
698 NS_LOG_V(DEBUG, "%s", __func__);
699 NSLockMessageListMutex();
701 NSMessageStateLL * iter = NSGetMessageStateList()->head;
704 NSMessageStateLL * del = iter;
709 NSGetMessageStateList()->head = NULL;
710 NSGetMessageStateList()->tail = NULL;
712 NSUnlockMessageListMutex();
714 pthread_mutex_t * mu = *NSGetMessageListMutex();
715 pthread_mutex_destroy(mu);
717 *NSGetMessageListMutex() = NULL;
719 NSMessageStateList * list = NSGetMessageStateList();
721 *NSGetMessageStateListAddr() = NULL;