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 "NSConsumerCommon.h"
22 #include "NSConstants.h"
24 #include "oic_malloc.h"
25 #include "oic_string.h"
26 #include "ocpayload.h"
30 pthread_mutex_t ** NSGetStackMutex()
32 static pthread_mutex_t * g_stackMutext = NULL;
33 if (g_stackMutext == NULL)
35 g_stackMutext = (pthread_mutex_t *)OICMalloc(sizeof(pthread_mutex_t));
36 NS_VERIFY_NOT_NULL(g_stackMutext, NULL);
37 pthread_mutex_init(g_stackMutext, NULL);
40 return & g_stackMutext;
43 char ** NSGetConsumerId()
45 static char * g_consumerId = NULL;
46 return & g_consumerId;
49 void NSSetConsumerId(char * cId)
51 NS_VERIFY_NOT_NULL_V(cId);
52 char ** consumerId = NSGetConsumerId();
53 NSOICFree(*consumerId);
54 *consumerId = (char *)OICMalloc(sizeof(char) * NS_DEVICE_ID_LENGTH);
55 NS_VERIFY_NOT_NULL_V(*consumerId);
57 OICStrcpy(*consumerId, sizeof(char) * NS_DEVICE_ID_LENGTH, cId);
60 char * NSMakeRequestUriWithConsumerId(const char * uri)
62 NS_VERIFY_NOT_NULL(uri, NULL);
64 char * consumerId = OICStrdup(*NSGetConsumerId());
65 NS_VERIFY_NOT_NULL(consumerId, NULL);
67 size_t uriLen = strlen(uri) + 1;
68 size_t qKeyLen = sizeof(NS_QUERY_CONSUMER_ID);
69 size_t queryLen = NS_DEVICE_ID_LENGTH + uriLen + qKeyLen + 2;
71 char * retQuery = (char *)OICMalloc(sizeof(char) * queryLen);
72 NS_VERIFY_NOT_NULL(retQuery, NULL);
75 OICStrcpy((retQuery + index), uriLen, uri);
77 OICStrcpy((retQuery + index), 2, "?");
79 OICStrcpy((retQuery + index), qKeyLen, NS_QUERY_CONSUMER_ID);
81 OICStrcpy((retQuery + index), 2, "=");
83 OICStrcpy((retQuery + index), NS_DEVICE_ID_LENGTH, consumerId);
85 NSOICFree(consumerId);
90 bool * NSGetBoneIsStartedConsumer()
92 static bool g_isStartedConsumer = false;
94 return & g_isStartedConsumer;
97 void NSSetIsStartedConsumer(bool setValue)
99 * NSGetBoneIsStartedConsumer() = setValue;
101 if (setValue == false)
103 pthread_mutex_destroy(*NSGetStackMutex());
104 NSOICFree(*NSGetStackMutex());
105 *NSGetStackMutex() = NULL;
107 NSOICFree(*NSGetConsumerId());
108 *NSGetConsumerId() = NULL;
112 bool NSIsStartedConsumer()
114 return * NSGetBoneIsStartedConsumer();
117 NSProviderStateCallback * NSGetProviderChangedCb()
119 static NSProviderStateCallback g_changedCb = NULL;
121 return & g_changedCb;
124 void NSSetProviderChangedCb(NSProviderStateCallback cb)
126 *(NSGetProviderChangedCb()) = cb;
131 NSProvider * provider;
132 NSProviderState state;
133 } NSProviderChangedData;
135 void * NSProviderChangedFunc(void * obj)
137 NSProviderChangedData * data = (NSProviderChangedData *) obj;
138 (*(NSGetProviderChangedCb()))(data->provider, data->state);
143 void NSProviderChanged(NSProvider * provider, NSProviderState response)
145 NS_VERIFY_NOT_NULL_V(provider);
147 NSProvider * retProvider = NSCopyProvider((NSProvider_internal *) provider);
148 NS_VERIFY_NOT_NULL_V(retProvider);
150 NSProviderChangedData * data =
151 (NSProviderChangedData *)OICMalloc(sizeof(NSProviderChangedData));
152 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(data, NSRemoveProvider(retProvider));
154 data->provider = retProvider;
155 data->state = response;
157 NSConsumerThread * thread = NSThreadInit(NSProviderChangedFunc, (void *) data);
158 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(thread,
160 NSRemoveProvider(retProvider);
164 NSDestroyThreadHandle(thread);
168 NSSyncInfoReceivedCallback * NSGetBoneNotificationSyncCb()
170 static NSSyncInfoReceivedCallback g_syncCb = NULL;
175 void NSSetNotificationSyncCb(NSSyncInfoReceivedCallback cb)
177 * NSGetBoneNotificationSyncCb() = cb;
180 void * NSNotificationSyncFunc(void * obj)
182 (* NSGetBoneNotificationSyncCb())((NSSyncInfo *) obj);
186 void NSNotificationSync(NSSyncInfo * sync)
188 NS_VERIFY_NOT_NULL_V(sync);
190 NSSyncInfo * retSync = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
191 NS_VERIFY_NOT_NULL_V(retSync);
192 memcpy(retSync, sync, sizeof(NSSyncInfo));
194 NSConsumerThread * thread = NSThreadInit(NSNotificationSyncFunc, (void *) retSync);
195 NS_VERIFY_NOT_NULL_V(thread);
197 NSDestroyThreadHandle(thread);
201 NSMessageReceivedCallback * NSGetBoneMessagePostedCb()
203 static NSMessageReceivedCallback g_postCb = NULL;
208 void NSSetMessagePostedCb(NSMessageReceivedCallback cb)
210 * NSGetBoneMessagePostedCb() = cb;
213 NSMessageReceivedCallback NSGetMessagePostedCb()
215 return * NSGetBoneMessagePostedCb();
218 void * NSMessagePostFunc(void * obj)
220 NSGetMessagePostedCb()((NSMessage *) obj);
224 void NSMessagePost(NSMessage * msg)
226 NS_VERIFY_NOT_NULL_V(msg);
228 NSMessage * retMsg = NSCopyMessage(msg);
229 NS_VERIFY_NOT_NULL_V(retMsg);
231 NSConsumerThread * thread = NSThreadInit(NSMessagePostFunc, (void *) retMsg);
232 NS_VERIFY_NOT_NULL_V(thread);
234 NSDestroyThreadHandle(thread);
238 NSTask * NSMakeTask(NSTaskType type, void * data)
240 NSTask * retTask = OICMalloc(sizeof(NSTask));
241 NS_VERIFY_NOT_NULL(retTask, NULL);
243 retTask->taskType = type;
244 retTask->taskData = data;
245 retTask->nextTask = NULL;
250 NSMessage * NSCopyMessage(NSMessage * msg)
252 NS_VERIFY_NOT_NULL(msg, NULL);
254 NSMessage * newMsg = (NSMessage *)OICMalloc(sizeof(NSMessage));
255 NS_VERIFY_NOT_NULL(newMsg, NULL);
257 OICStrcpy(newMsg->providerId, NS_DEVICE_ID_LENGTH, msg->providerId);
259 newMsg->messageId = msg->messageId;
260 newMsg->title = OICStrdup(msg->title);
261 newMsg->contentText = OICStrdup(msg->contentText);
262 newMsg->sourceName = OICStrdup(msg->sourceName);
263 newMsg->dateTime = OICStrdup(msg->dateTime);
264 newMsg->type = msg->type;
265 newMsg->ttl= msg->ttl;
267 newMsg->topic = NULL;
268 if (msg->topic && strlen(msg->topic) > 0)
270 newMsg->topic = OICStrdup(msg->topic);
273 newMsg->mediaContents = NULL;
274 if (msg->mediaContents)
276 newMsg->mediaContents = (NSMediaContents *)OICMalloc(sizeof(NSMediaContents));
277 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(
278 newMsg->mediaContents, NULL, NSRemoveMessage(newMsg));
279 newMsg->mediaContents->iconImage =
280 (char *)OICMalloc(sizeof(char)*strlen(msg->mediaContents->iconImage) + 1);
281 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(
282 newMsg->mediaContents->iconImage, NULL, NSRemoveMessage(newMsg));
283 memcpy(newMsg->mediaContents->iconImage, msg->mediaContents->iconImage,
284 strlen(msg->mediaContents->iconImage) + 1);
287 newMsg->extraInfo = NULL;
290 newMsg->extraInfo = OCRepPayloadClone(msg->extraInfo);
295 void NSRemoveMessage(NSMessage * msg)
297 NS_VERIFY_NOT_NULL_V(msg);
300 NSOICFree(msg->title);
301 NSOICFree(msg->contentText);
302 NSOICFree(msg->sourceName);
303 NSOICFree(msg->dateTime);
304 NSOICFree(msg->topic);
306 if (msg->mediaContents)
308 NSOICFree(msg->mediaContents->iconImage);
310 NSOICFree(msg->mediaContents);
314 OCRepPayloadDestroy(msg->extraInfo);
315 msg->extraInfo = NULL;
321 void NSRemoveConnections(NSProviderConnectionInfo * connections)
323 NS_VERIFY_NOT_NULL_V(connections);
325 NSProviderConnectionInfo * tmp = connections;
329 tmp->messageHandle = NULL;
330 tmp->syncHandle = NULL;
331 NSOICFree(tmp->addr);
332 NSProviderConnectionInfo * next = tmp->next;
338 NSProviderConnectionInfo * NSCreateProviderConnections(OCDevAddr * inAddr)
340 NSProviderConnectionInfo * connections
341 = (NSProviderConnectionInfo *)OICMalloc(sizeof(NSProviderConnectionInfo));
342 NS_VERIFY_NOT_NULL(connections, NULL);
344 connections->addr = NULL;
345 connections->messageHandle = NULL;
346 connections->syncHandle = NULL;
347 connections->isCloudConnection = false;
348 connections->isSubscribing = false;
349 connections->next = NULL;
353 connections->addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
354 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(connections->addr, NULL, NSRemoveConnections(connections));
355 memcpy(connections->addr, inAddr, sizeof(OCDevAddr));
361 NSProviderConnectionInfo * NSCopyProviderConnections(NSProviderConnectionInfo * conn)
363 NS_VERIFY_NOT_NULL(conn, NULL);
364 NSProviderConnectionInfo * tmp = conn;
366 NSProviderConnectionInfo * retInfo = NSCreateProviderConnections(tmp->addr);
367 NS_VERIFY_NOT_NULL(retInfo, NULL);
368 retInfo->messageHandle = tmp->messageHandle;
369 retInfo->syncHandle = tmp->syncHandle;
370 retInfo->isCloudConnection = tmp->isCloudConnection;
371 retInfo->isSubscribing = tmp->isSubscribing;
374 NSProviderConnectionInfo * copyInfo = retInfo;
378 NSProviderConnectionInfo * tmpInfo = NSCreateProviderConnections(tmp->addr);
379 NS_VERIFY_NOT_NULL(tmpInfo, NULL);
381 tmpInfo->messageHandle = tmp->messageHandle;
382 tmpInfo->syncHandle = tmp->syncHandle;
383 tmpInfo->isCloudConnection = tmp->isCloudConnection;
384 tmpInfo->isSubscribing = tmp->isSubscribing;
386 copyInfo->next = tmpInfo;
393 void NSRemoveTopicNode(NSTopicLL * topicNode)
395 NS_VERIFY_NOT_NULL_V(topicNode);
397 NSOICFree(topicNode->topicName);
398 topicNode->next = NULL;
400 NSOICFree(topicNode);
403 NSTopicLL * NSCopyTopicNode(NSTopicLL * topicNode)
405 NS_VERIFY_NOT_NULL(topicNode, NULL);
407 NSTopicLL * newTopicNode = (NSTopicLL *)OICMalloc(sizeof(NSTopicLL));
408 NS_VERIFY_NOT_NULL(newTopicNode, NULL);
410 newTopicNode->topicName = OICStrdup(topicNode->topicName);
411 newTopicNode->state = topicNode->state;
412 newTopicNode->next = NULL;
417 NSResult NSInsertTopicNode(NSTopicLL * topicHead, NSTopicLL * topicNode)
419 NS_VERIFY_NOT_NULL(topicHead, NS_ERROR);
420 NS_VERIFY_NOT_NULL(topicNode, NS_ERROR);
422 NSTopicLL * iter = topicHead;
423 NSTopicLL * prev = NULL;
428 iter = (NSTopicLL *) iter->next;
431 prev->next = topicNode;
432 topicNode->next = NULL;
437 void NSRemoveTopicLL(NSTopicLL * topicHead)
439 NS_VERIFY_NOT_NULL_V(topicHead);
441 NSTopicLL * iter = topicHead;
442 NSTopicLL * following = NULL;
446 following = iter->next;
448 NSRemoveTopicNode(iter);
454 NSTopicLL * NSCopyTopicLL(NSTopicLL * topicHead)
456 NS_VERIFY_NOT_NULL(topicHead, NULL);
458 NSTopicLL * iter = topicHead;
460 NS_LOG_V(DEBUG, "[NSCopyTopicLL] Name:%s\t State:%d", iter->topicName, iter->state);
461 NSTopicLL * newTopicHead = NSCopyTopicNode(iter);
462 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicHead, NULL, NSRemoveTopicLL(newTopicHead));
464 iter = (NSTopicLL *) iter->next;
468 NS_LOG_V(DEBUG, "[NSCopyTopicLL] Name:%s\t State:%d", iter->topicName, iter->state);
469 NSTopicLL * newTopicNode = NSCopyTopicNode(iter);
470 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicNode, NULL, NSRemoveTopicLL(newTopicHead));
472 NSResult ret = NSInsertTopicNode(newTopicHead, newTopicNode);
473 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *)1 : NULL,
474 NULL, NSRemoveTopicLL(newTopicHead));
476 iter = (NSTopicLL *) iter->next;
482 void NSCopyProviderPostClean(
483 NSProviderConnectionInfo * connections, NSProvider_internal * provider)
485 NSRemoveConnections(connections);
489 NSProvider_internal * NSCopyProvider_internal(NSProvider_internal * prov)
491 NS_VERIFY_NOT_NULL(prov, NULL);
493 NSProviderConnectionInfo * connections = NSCopyProviderConnections(prov->connection);
494 NS_VERIFY_NOT_NULL(connections, NULL);
496 NSProvider_internal * newProv = (NSProvider_internal *) OICMalloc(sizeof(NSProvider_internal));
497 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProv, NULL, NSRemoveConnections(connections));
499 newProv->topicLL = NULL;
503 NSTopicLL * newTopicLL = NSCopyTopicLL(prov->topicLL);
504 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicLL, NULL,
505 NSCopyProviderPostClean(connections, newProv));
507 newProv->topicLL = newTopicLL;
510 newProv->connection = connections;
511 OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
512 newProv->messageUri = OICStrdup(prov->messageUri);
513 newProv->syncUri = OICStrdup(prov->syncUri);
514 newProv->topicUri = OICStrdup(prov->topicUri);
515 newProv->accessPolicy = prov->accessPolicy;
516 newProv->state = prov->state;
521 NSProvider * NSCopyProvider(NSProvider_internal * prov)
523 NS_VERIFY_NOT_NULL(prov, NULL);
525 NSProvider * newProv = (NSProvider *) OICMalloc(sizeof(NSProvider));
526 NS_VERIFY_NOT_NULL(newProv, NULL);
528 OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
533 void NSRemoveProvider_internal(void * data)
535 NS_VERIFY_NOT_NULL_V(data);
537 NSProvider_internal * prov = (NSProvider_internal *) data;
539 NSOICFree(prov->messageUri);
540 NSOICFree(prov->syncUri);
541 NSOICFree(prov->topicUri);
542 NSRemoveConnections(prov->connection);
545 NSRemoveTopicLL(prov->topicLL);
551 void NSRemoveProvider(NSProvider * prov)
553 NS_VERIFY_NOT_NULL_V(prov);
557 OCStackResult NSInvokeRequest(OCDoHandle * handle,
558 OCMethod method, const OCDevAddr * addr,
559 const char * queryUrl, OCPayload * payload,
560 void * callbackFunc, void * callbackData,
561 OCClientContextDeleter cd, OCConnectivityType type)
563 int mutexRet = pthread_mutex_lock(*(NSGetStackMutex()));
564 NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
566 OCCallbackData cbdata = { NULL, NULL, NULL };
568 cbdata.cb = callbackFunc;
569 cbdata.context = callbackData;
572 OCStackResult ret = OCDoResource(handle, method, queryUrl, addr,
573 payload, type, NS_QOS, &cbdata, NULL, 0);
575 mutexRet = pthread_mutex_unlock(*(NSGetStackMutex()));
576 NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
581 bool NSOCResultToSuccess(OCStackResult ret)
586 case OC_STACK_RESOURCE_CREATED:
587 case OC_STACK_RESOURCE_DELETED:
588 case OC_STACK_PRESENCE_STOPPED:
589 case OC_STACK_CONTINUE:
590 case OC_STACK_RESOURCE_CHANGED:
593 NS_LOG_V(DEBUG, "OCStackResult : %d", (int)ret);