2 //******************************************************************
4 // Copyright 2016 Samsung Electronics All Rights Reserved.
6 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
8 // Licensed under the Apache License, Version 2.0 (the "License");
9 // you may not use this file except in compliance with the License.
10 // You may obtain a copy of the License at
12 // http://www.apache.org/licenses/LICENSE-2.0
14 // Unless required by applicable law or agreed to in writing, software
15 // distributed under the License is distributed on an "AS IS" BASIS,
16 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 // See the License for the specific language governing permissions and
18 // limitations under the License.
20 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
22 #include "NSConsumerCommon.h"
23 #include "NSConstants.h"
25 #include "oic_malloc.h"
26 #include "oic_string.h"
30 #define NS_QUERY_CONSUMER_ID "consumerid"
32 pthread_mutex_t ** NSGetStackMutex()
34 static pthread_mutex_t * g_stackMutext = NULL;
35 if (g_stackMutext == NULL)
37 g_stackMutext = (pthread_mutex_t *)OICMalloc(sizeof(pthread_mutex_t));
38 NS_VERIFY_NOT_NULL(g_stackMutext, NULL);
39 pthread_mutex_init(g_stackMutext, NULL);
42 return & g_stackMutext;
45 char ** NSGetConsumerId()
47 static char * g_consumerId = NULL;
48 return & g_consumerId;
51 void NSSetConsumerId(char * cId)
53 NS_VERIFY_NOT_NULL_V(cId);
54 char ** consumerId = NSGetConsumerId();
55 NSOICFree(*consumerId);
56 *consumerId = (char *)OICMalloc(sizeof(char) * NS_DEVICE_ID_LENGTH);
57 NS_VERIFY_NOT_NULL_V(*consumerId);
59 OICStrcpy(*consumerId, sizeof(char) * NS_DEVICE_ID_LENGTH, cId);
62 char * NSMakeRequestUriWithConsumerId(const char * uri)
64 NS_VERIFY_NOT_NULL(uri, NULL);
66 char * consumerId = OICStrdup(*NSGetConsumerId());
67 NS_VERIFY_NOT_NULL(consumerId, NULL);
69 size_t uriLen = strlen(uri) + 1;
70 size_t qKeyLen = sizeof(NS_QUERY_CONSUMER_ID);
71 size_t queryLen = NS_DEVICE_ID_LENGTH + uriLen + qKeyLen + 2;
73 char * retQuery = (char *)OICMalloc(sizeof(char) * queryLen);
74 NS_VERIFY_NOT_NULL(retQuery, NULL);
77 OICStrcpy((retQuery + index), uriLen, uri);
79 OICStrcpy((retQuery + index), 2, "?");
81 OICStrcpy((retQuery + index), qKeyLen, NS_QUERY_CONSUMER_ID);
83 OICStrcpy((retQuery + index), 2, "=");
85 OICStrcpy((retQuery + index), NS_DEVICE_ID_LENGTH, consumerId);
87 NSOICFree(consumerId);
92 bool * NSGetBoneIsStartedConsumer()
94 static bool g_isStartedConsumer = false;
96 return & g_isStartedConsumer;
99 void NSSetIsStartedConsumer(bool setValue)
101 * NSGetBoneIsStartedConsumer() = setValue;
104 bool NSIsStartedConsumer()
106 return * NSGetBoneIsStartedConsumer();
109 NSProviderDiscoveredCallback * NSGetBoneDiscoverCb()
111 static NSProviderDiscoveredCallback g_discoverCb = NULL;
113 return & g_discoverCb;
116 void NSSetDiscoverProviderCb(NSProviderDiscoveredCallback cb)
118 * NSGetBoneDiscoverCb() = cb;
121 NSProviderDiscoveredCallback NSGetDiscoverCb()
123 return * NSGetBoneDiscoverCb();
126 void * NSDiscoveredProviderFunc(void * provider)
128 NSGetDiscoverCb()((NSProvider *) provider);
133 void NSDiscoveredProvider(NSProvider * provider)
135 NS_VERIFY_NOT_NULL_V(provider);
137 NSProvider * retProvider = (NSProvider *)NSCopyProvider_internal((NSProvider_internal *)provider);
138 NS_VERIFY_NOT_NULL_V(retProvider);
140 NSConsumerThread * thread = NSThreadInit(NSDiscoveredProviderFunc, (void *) retProvider);
141 NS_VERIFY_NOT_NULL_V(thread);
144 NSProviderChangedCallback * NSGetProviderChangedCb()
146 static NSProviderChangedCallback g_changedCb = NULL;
148 return & g_changedCb;
151 void NSSetProviderChangedCb(NSProviderChangedCallback cb)
153 *(NSGetProviderChangedCb()) = cb;
156 void NSProviderChanged(NSProvider * provider, NSResponse response)
158 (*(NSGetProviderChangedCb()))(provider, response);
161 NSSyncInfoReceivedCallback * NSGetBoneNotificationSyncCb()
163 static NSSyncInfoReceivedCallback g_syncCb = NULL;
168 void NSSetNotificationSyncCb(NSSyncInfoReceivedCallback cb)
170 * NSGetBoneNotificationSyncCb() = cb;
173 void * NSNotificationSyncFunc(void * obj)
175 (* NSGetBoneNotificationSyncCb())((NSSyncInfo *) obj);
179 void NSNotificationSync(NSSyncInfo * sync)
181 NS_VERIFY_NOT_NULL_V(sync);
183 NSSyncInfo * retSync = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
184 NS_VERIFY_NOT_NULL_V(retSync);
185 memcpy(retSync, sync, sizeof(NSSyncInfo));
187 NSConsumerThread * thread = NSThreadInit(NSNotificationSyncFunc, (void *) retSync);
188 NS_VERIFY_NOT_NULL_V(thread);
191 NSMessageReceivedCallback * NSGetBoneMessagePostedCb()
193 static NSMessageReceivedCallback g_postCb = NULL;
198 void NSSetMessagePostedCb(NSMessageReceivedCallback cb)
200 * NSGetBoneMessagePostedCb() = cb;
203 NSMessageReceivedCallback NSGetMessagePostedCb()
205 return * NSGetBoneMessagePostedCb();
208 void * NSMessagePostFunc(void * obj)
210 NSGetMessagePostedCb()((NSMessage *) obj);
214 void NSMessagePost(NSMessage * msg)
216 NS_VERIFY_NOT_NULL_V(msg);
218 NSMessage * retMsg = NSCopyMessage(msg);
219 NS_VERIFY_NOT_NULL_V(retMsg);
221 NSConsumerThread * thread = NSThreadInit(NSMessagePostFunc, (void *) retMsg);
222 NS_VERIFY_NOT_NULL_V(thread);
225 NSTask * NSMakeTask(NSTaskType type, void * data)
227 NSTask * retTask = OICMalloc(sizeof(NSTask));
228 NS_VERIFY_NOT_NULL(retTask, NULL);
230 retTask->taskType = type;
231 retTask->taskData = data;
232 retTask->nextTask = NULL;
237 NSMessage * NSCopyMessage(NSMessage * msg)
239 NS_VERIFY_NOT_NULL(msg, NULL);
241 NSMessage * newMsg = (NSMessage *)OICMalloc(sizeof(NSMessage));
242 NS_VERIFY_NOT_NULL(newMsg, NULL);
244 OICStrcpy(newMsg->providerId, NS_DEVICE_ID_LENGTH, msg->providerId);
246 newMsg->messageId = msg->messageId;
247 newMsg->title = OICStrdup(msg->title);
248 newMsg->contentText = OICStrdup(msg->contentText);
249 newMsg->sourceName = OICStrdup(msg->sourceName);
250 newMsg->dateTime = OICStrdup(msg->dateTime);
251 newMsg->type = msg->type;
253 // TODO change to copy function.
254 newMsg->mediaContents = msg->mediaContents;
258 void NSRemoveMessage(NSMessage * msg)
260 NS_VERIFY_NOT_NULL_V(msg);
263 NSOICFree(msg->title);
264 NSOICFree(msg->contentText);
265 NSOICFree(msg->sourceName);
266 NSOICFree(msg->dateTime);
268 // TODO change to remove function.
269 NSOICFree(msg->mediaContents);
274 void NSRemoveConnections(NSProviderConnectionInfo * connections)
276 NS_VERIFY_NOT_NULL_V(connections);
278 NSProviderConnectionInfo * tmp = connections;
282 tmp->messageHandle = NULL;
283 tmp->syncHandle = NULL;
284 NSOICFree(tmp->addr);
288 NSOICFree(connections);
291 NSProviderConnectionInfo * NSCreateProviderConnections(OCDevAddr * inAddr)
293 NSProviderConnectionInfo * connections
294 = (NSProviderConnectionInfo *)OICMalloc(sizeof(NSProviderConnectionInfo));
295 NS_VERIFY_NOT_NULL(connections, NULL);
297 connections->addr = NULL;
298 connections->messageHandle = NULL;
299 connections->syncHandle = NULL;
300 connections->isCloudConnection = false;
301 connections->isSubscribing = false;
302 connections->next = NULL;
306 connections->addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
307 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(connections->addr, NULL, NSRemoveConnections(connections));
308 memcpy(connections->addr, inAddr, sizeof(OCDevAddr));
314 NSProviderConnectionInfo * NSCopyProviderConnections(NSProviderConnectionInfo * conn)
316 NS_VERIFY_NOT_NULL(conn, NULL);
317 NSProviderConnectionInfo * tmp = conn;
319 NSProviderConnectionInfo * retInfo = NSCreateProviderConnections(tmp->addr);
320 NS_VERIFY_NOT_NULL(retInfo, NULL);
322 NSProviderConnectionInfo * copyInfo = retInfo;
326 copyInfo = NSCreateProviderConnections(tmp->addr);
327 NS_VERIFY_NOT_NULL(copyInfo, NULL);
329 copyInfo->messageHandle = tmp->messageHandle;
330 copyInfo->syncHandle = tmp->syncHandle;
331 copyInfo->isCloudConnection = tmp->isCloudConnection;
332 copyInfo->isSubscribing = tmp->isSubscribing;
334 copyInfo = copyInfo->next;
340 void NSRemoveTopicNode(NSTopicLL * topicNode)
342 NS_VERIFY_NOT_NULL_V(topicNode);
344 NSOICFree(topicNode->topicName);
345 topicNode->next = NULL;
347 NSOICFree(topicNode);
350 NSTopicLL * NSCopyTopicNode(NSTopicLL * topicNode)
352 NS_VERIFY_NOT_NULL(topicNode, NULL);
354 NSTopicLL * newTopicNode = (NSTopicLL *)OICMalloc(sizeof(NSTopicLL));
355 NS_VERIFY_NOT_NULL(newTopicNode, NULL);
357 newTopicNode->topicName = OICStrdup(topicNode->topicName);
358 newTopicNode->state = topicNode->state;
359 newTopicNode->next = NULL;
364 NSResult NSInsertTopicNode(NSTopicLL * topicHead, NSTopicLL * topicNode)
366 NS_VERIFY_NOT_NULL(topicHead, NS_ERROR);
367 NS_VERIFY_NOT_NULL(topicNode, NS_ERROR);
369 NSTopicLL * iter = topicHead;
370 NSTopicLL * prev = NULL;
375 iter = (NSTopicLL *) iter->next;
378 prev->next = topicNode;
379 topicNode->next = NULL;
384 void NSRemoveTopicLL(NSTopicLL * topicHead)
386 NS_VERIFY_NOT_NULL_V(topicHead);
388 NSTopicLL * iter = topicHead;
389 NSTopicLL * following = NULL;
393 following = (NSTopicLL *) iter->next;
395 NSRemoveTopicNode(iter);
401 NSTopicLL * NSCopyTopicLL(NSTopicLL * topicHead)
403 NS_VERIFY_NOT_NULL(topicHead, NULL);
405 NSTopicLL * iter = topicHead;
407 NSTopicLL * newTopicHead = NSCopyTopicNode(iter);
408 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicHead, NULL, NSRemoveTopicLL(newTopicHead));
410 iter = (NSTopicLL *) iter->next;
414 NSTopicLL * newTopicNode = NSCopyTopicNode(iter);
415 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicNode, NULL, NSRemoveTopicLL(newTopicHead));
417 NSResult ret = NSInsertTopicNode(newTopicHead, newTopicNode);
418 NS_VERIFY_STACK_SUCCESS_WITH_POST_CLEANING(ret, NULL, NSRemoveTopicLL(newTopicHead));
420 iter = (NSTopicLL *) iter->next;
426 void NSCopyProviderPostClean(
427 NSProviderConnectionInfo * connections, NSProvider_internal * provider)
429 NSRemoveConnections(connections);
433 NSProvider_internal * NSCopyProvider_internal(NSProvider_internal * prov)
435 NS_VERIFY_NOT_NULL(prov, NULL);
437 NSProviderConnectionInfo * connections = NSCopyProviderConnections(prov->connection);
438 NS_VERIFY_NOT_NULL(connections, NULL);
440 NSProvider_internal * newProv = (NSProvider_internal *) OICMalloc(sizeof(NSProvider_internal));
441 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProv, NULL, NSRemoveConnections(connections));
443 newProv->topicLL = NULL;
447 NSTopicLL * newTopicLL = NSCopyTopicLL(prov->topicLL);
448 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicLL, NULL,
449 NSCopyProviderPostClean(connections, newProv));
451 newProv->topicLL = newTopicLL;
454 newProv->connection = connections;
455 OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
456 newProv->messageUri = OICStrdup(prov->messageUri);
457 newProv->syncUri = OICStrdup(prov->syncUri);
458 newProv->topicUri = OICStrdup(prov->topicUri);
459 newProv->accessPolicy = prov->accessPolicy;
464 NSProvider * NSCopyProvider(NSProvider_internal * prov)
466 NS_VERIFY_NOT_NULL(prov, NULL);
468 NSProvider * newProv = (NSProvider *) OICMalloc(sizeof(NSProvider));
469 NS_VERIFY_NOT_NULL(newProv, NULL);
471 newProv->topicLL = NULL;
475 NSTopicLL * topicList = NSCopyTopicLL(prov->topicLL);
476 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(topicList, NULL, NSRemoveProvider(newProv));
478 newProv->topicLL = topicList;
481 OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
486 void NSRemoveProvider_internal(NSProvider_internal * prov)
488 NS_VERIFY_NOT_NULL_V(prov);
490 NSOICFree(prov->messageUri);
491 NSOICFree(prov->syncUri);
492 NSOICFree(prov->topicUri);
493 NSRemoveConnections(prov->connection);
496 NSRemoveTopicLL(prov->topicLL);
502 void NSRemoveProvider(NSProvider * prov)
504 NS_VERIFY_NOT_NULL_V(prov);
508 NSRemoveTopicLL(prov->topicLL);
514 NSSyncInfo_internal * NSCopySyncInfo(NSSyncInfo_internal * syncInfo)
516 NS_VERIFY_NOT_NULL(syncInfo, NULL);
518 NSProviderConnectionInfo * connections = NSCopyProviderConnections(syncInfo->connection);
519 NS_VERIFY_NOT_NULL(connections, NULL);
521 NSSyncInfo_internal * newSyncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
522 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newSyncInfo, NULL, NSRemoveConnections(connections));
524 OICStrcpy(newSyncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, syncInfo->providerId);
525 newSyncInfo->messageId = syncInfo->messageId;
526 newSyncInfo->state = syncInfo->state;
527 newSyncInfo->connection = connections;
532 void NSRemoveSyncInfo(NSSyncInfo_internal * syncInfo)
534 NS_VERIFY_NOT_NULL_V(syncInfo);
536 NSRemoveConnections(syncInfo->connection);
541 OCStackResult NSInvokeRequest(OCDoHandle * handle,
542 OCMethod method, const OCDevAddr * addr,
543 const char * queryUrl, OCPayload * payload,
544 void * callbackFunc, void * callbackData, OCConnectivityType type)
546 int mutexRet = pthread_mutex_lock(*(NSGetStackMutex()));
547 NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
549 OCCallbackData cbdata = { 0, };
551 cbdata.cb = callbackFunc;
552 cbdata.context = callbackData;
555 OCStackResult ret = OCDoResource(handle, method, queryUrl, addr,
556 payload, type, NS_QOS, &cbdata, NULL, 0);
558 mutexRet = pthread_mutex_unlock(*(NSGetStackMutex()));
559 NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
564 bool NSOCResultToSuccess(OCStackResult ret)
569 case OC_STACK_RESOURCE_CREATED:
570 case OC_STACK_RESOURCE_DELETED:
571 case OC_STACK_CONTINUE:
572 case OC_STACK_RESOURCE_CHANGED:
575 NS_LOG_V(DEBUG, "OCStackResult : %d", (int)ret);