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 NSCacheList ** NSGetMessageCacheList()
31 static NSCacheList * messageCache = NULL;
32 return & messageCache;
35 void NSSetMessageCacheList(NSCacheList * cache)
37 *(NSGetMessageCacheList()) = cache;
40 NSCacheList ** NSGetProviderCacheList()
42 static NSCacheList * providerCache = NULL;
43 return & providerCache;
46 void NSSetProviderCacheList(NSCacheList * cache)
48 *(NSGetProviderCacheList()) = cache;
51 void NSDestroyMessageCacheList()
53 NSCacheList * cache = *(NSGetMessageCacheList());
56 NSStorageDestroy(cache);
59 NSSetMessageCacheList(NULL);
62 void NSDestroyProviderCacheList()
64 NSCacheList * cache = *(NSGetProviderCacheList());
67 NSStorageDestroy(cache);
70 NSSetProviderCacheList(NULL);
73 NSMessage_consumer * NSMessageCacheFind(const char * messageId)
75 NS_VERIFY_NOT_NULL(messageId, NULL);
77 NSCacheList * MessageCache = *(NSGetMessageCacheList());
80 NS_LOG(DEBUG, "Message Cache Init");
81 MessageCache = NSStorageCreate();
82 NS_VERIFY_NOT_NULL(MessageCache, NULL);
84 MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
85 NSSetMessageCacheList(MessageCache);
88 NSCacheElement * cacheElement = NSStorageRead(MessageCache, messageId);
89 NS_VERIFY_NOT_NULL(cacheElement, NULL);
91 return NSCopyMessage((NSMessage_consumer *) cacheElement->data);
94 NSProvider_internal * NSProviderCacheFind(const char * providerId)
96 NS_VERIFY_NOT_NULL(providerId, NULL);
98 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
101 NS_LOG(DEBUG, "Provider Cache Init");
102 ProviderCache = NSStorageCreate();
103 NS_VERIFY_NOT_NULL(ProviderCache, NULL);
105 ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
106 NSSetProviderCacheList(ProviderCache);
109 NSCacheElement * cacheElement = NSStorageRead(ProviderCache, providerId);
110 NS_VERIFY_NOT_NULL(cacheElement, NULL);
112 return NSCopyProvider((NSProvider_internal *) cacheElement->data);
116 NSResult NSMessageCacheUpdate(NSMessage_consumer * msg, NSSyncType type)
118 NSCacheList * MessageCache = *(NSGetMessageCacheList());
121 NS_LOG(DEBUG, "Message Cache Init");
122 MessageCache = NSStorageCreate();
123 NS_VERIFY_NOT_NULL(MessageCache, NS_ERROR);
125 MessageCache->cacheType = NS_CONSUMER_CACHE_MESSAGE;
126 NSSetMessageCacheList(MessageCache);
129 NS_VERIFY_NOT_NULL(msg, NS_ERROR);
133 NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
134 NS_VERIFY_NOT_NULL(obj, NS_ERROR);
136 obj->data = (NSCacheData *) msg;
139 NS_LOG(DEBUG, "try to write to storage");
140 NSResult ret = NSStorageWrite(MessageCache, obj);
141 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
142 NS_ERROR, NSOICFree(obj));
147 NSResult NSProviderCacheUpdate(NSProvider_internal * provider)
149 NSCacheList * ProviderCache = *(NSGetProviderCacheList());
152 NS_LOG(DEBUG, "Provider Cache Init");
153 ProviderCache = NSStorageCreate();
154 NS_VERIFY_NOT_NULL(ProviderCache, NS_ERROR);
156 ProviderCache->cacheType = NS_CONSUMER_CACHE_PROVIDER;
157 NSSetProviderCacheList(ProviderCache);
160 NS_VERIFY_NOT_NULL(provider, NS_ERROR);
162 NSCacheElement * obj = (NSCacheElement *)OICMalloc(sizeof(NSCacheElement));
163 NS_VERIFY_NOT_NULL(obj, NS_ERROR);
165 obj->data = (NSCacheData *) provider;
168 NS_LOG(DEBUG, "try to write to storage");
169 NSResult ret = NSStorageWrite(ProviderCache, obj);
170 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *) 1 : NULL,
171 NS_ERROR, NSOICFree(obj));
176 void NSConsumerHandleProviderDiscovered(NSProvider_internal * provider)
178 NS_VERIFY_NOT_NULL_V(provider);
181 bool isSubscribing = false;
182 NSProvider_internal * providerCacheData = NSProviderCacheFind(provider->providerId);
184 if (providerCacheData == NULL)
190 providerCacheData->accessPolicy = provider->accessPolicy;
191 NSProviderConnectionInfo * infos = providerCacheData->connection;
192 OCTransportAdapter newAdapter = provider->connection->addr->adapter;
195 isSubscribing |= infos->isSubscribing;
196 if (infos->addr->adapter == newAdapter && infos->isSubscribing == true)
198 NS_LOG_V(DEBUG, "This provider already discovered : %s:%d",
199 infos->addr->addr, infos->addr->port);
200 NS_LOG_V(DEBUG, "Subscription : %d", infos->isSubscribing);
207 NSResult ret = NSProviderCacheUpdate(provider);
208 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
210 if (isAdded == false)
212 NS_LOG(DEBUG, "New provider is discovered");
216 provider = providerCacheData;
217 NS_LOG(DEBUG, "provider's connection is updated.");
220 if (provider->accessPolicy == NS_ACCESS_DENY && isSubscribing == false)
222 NS_LOG(DEBUG, "accepter is NS_ACCEPTER_CONSUMER, Callback to user");
223 NSDiscoveredProvider((NSProvider *) provider);
227 NS_LOG(DEBUG, "accepter is NS_ACCEPTER_PROVIDER, request subscribe");
228 NSProvider_internal * subProvider = NSCopyProvider(provider);
229 NSTask * task = NSMakeTask(TASK_CONSUMER_REQ_SUBSCRIBE, (void *) subProvider);
230 NS_VERIFY_NOT_NULL_V(task);
232 NSConsumerPushEvent(task);
235 NSRemoveProvider(providerCacheData);
238 void NSConsumerHandleProviderDeleted(NSProvider_internal * provider)
240 NS_VERIFY_NOT_NULL_V(provider);
242 NSCacheList * providerCache = *(NSGetProviderCacheList());
243 NS_VERIFY_NOT_NULL_V(providerCache);
245 NSResult ret = NSStorageDelete(providerCache, provider->providerId);
246 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
249 void NSConsumerHandleRecvSubscriptionConfirmed(NSMessage_consumer * msg)
251 NS_VERIFY_NOT_NULL_V(msg);
253 NS_LOG_V(DEBUG, "confirmed by : %s", msg->providerId);
254 NSProvider_internal * provider = NSProviderCacheFind(msg->providerId);
255 NS_VERIFY_NOT_NULL_V(provider);
257 if (provider->connection->next == NULL)
259 NSSubscriptionAccepted((NSProvider *) provider);
263 void NSConsumerHandleRecvMessage(NSMessage_consumer * msg)
265 NS_VERIFY_NOT_NULL_V(msg);
267 NSResult ret = NSMessageCacheUpdate(msg, NS_SYNC_UNREAD);
268 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
270 NSMessagePost((NSMessage *) msg);
273 void NSConsumerHandleRecvSyncInfo(NSSyncInfo * sync)
275 NS_VERIFY_NOT_NULL_V(sync);
277 char msgId[NS_DEVICE_ID_LENGTH] = { 0, };
278 snprintf(msgId, NS_DEVICE_ID_LENGTH, "%lld", (long long int)sync->messageId);
280 NSMessage_consumer * msg = NSMessageCacheFind(msgId);
281 NS_VERIFY_NOT_NULL_V(msg);
283 NSResult ret = NSMessageCacheUpdate(msg, sync->state);
284 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *) 1 : NULL);
285 NSRemoveMessage(msg);
287 NSNotificationSync(sync);
290 void NSConsumerHandleMakeSyncInfo(NSSyncInfo * sync)
292 NS_VERIFY_NOT_NULL_V(sync);
294 NSProvider_internal * provider = NSProviderCacheFind(sync->providerId);
295 NS_VERIFY_NOT_NULL_V (provider);
297 NSProviderConnectionInfo * connections = NSCopyProviderConnections(provider->connection);
298 NS_VERIFY_NOT_NULL_V (connections);
300 NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
301 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncInfo, NSRemoveConnections(connections));
303 OICStrcpy(syncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, sync->providerId);
304 syncInfo->messageId = sync->messageId;
305 syncInfo->state = sync->state;
306 syncInfo->connection = connections;
308 NSTask * syncTask = NSMakeTask(TASK_SEND_SYNCINFO, (void *) syncInfo);
309 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(syncTask, NSOICFree(syncInfo));
311 NSConsumerPushEvent(syncTask);
314 void NSConsumerInternalTaskProcessing(NSTask * task)
316 NS_VERIFY_NOT_NULL_V(task);
318 NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
319 switch (task->taskType)
321 case TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED:
323 NS_LOG(DEBUG, "Receive Subscribe confirm from provider.");
324 NSConsumerHandleRecvSubscriptionConfirmed((NSMessage_consumer *)task->taskData);
325 NSRemoveMessage((NSMessage_consumer *)task->taskData);
328 case TASK_CONSUMER_RECV_MESSAGE:
330 NS_LOG(DEBUG, "Receive New Notification");
331 NSConsumerHandleRecvMessage((NSMessage_consumer *)task->taskData);
332 NSRemoveMessage((NSMessage_consumer *)task->taskData);
335 case TASK_CONSUMER_PROVIDER_DISCOVERED:
337 NS_LOG(DEBUG, "Receive New Provider is discovered.");
338 NSConsumerHandleProviderDiscovered((NSProvider_internal *)task->taskData);
339 NSRemoveProvider((NSProvider_internal *)task->taskData);
342 case TASK_RECV_SYNCINFO:
344 NS_LOG(DEBUG, "Receive SyncInfo.");
345 NSConsumerHandleRecvSyncInfo((NSSyncInfo *)task->taskData);
346 NSOICFree(task->taskData);
349 case TASK_MAKE_SYNCINFO:
351 NS_LOG(DEBUG, "Make SyncInfo, get Provider's Addr");
352 NSConsumerHandleMakeSyncInfo((NSSyncInfo *)task->taskData);
353 NSOICFree(task->taskData);
356 case TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL:
358 NSConsumerHandleProviderDeleted((NSProvider_internal *)task->taskData);
359 NSRemoveProvider((NSProvider_internal *)task->taskData);
364 NS_LOG(ERROR, "Unknown TASK Type");