#include "NSThread.h"
#include "oic_malloc.h"
#include "oic_string.h"
+#include "ocpayload.h"
#include <pthread.h>
-#define NS_QUERY_CONSUMER_ID "consumerid"
+static bool NSIsExtraValue(const char * name);
+static void NSCopyPayloadValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source);
+static OCRepPayloadValue * NSCopyPayloadValue(OCRepPayloadValue * value);
pthread_mutex_t ** NSGetStackMutex()
{
void NSSetIsStartedConsumer(bool setValue)
{
* NSGetBoneIsStartedConsumer() = setValue;
+
+ if (setValue == false)
+ {
+ pthread_mutex_destroy(*NSGetStackMutex());
+ NSOICFree(*NSGetStackMutex());
+ *NSGetStackMutex() = NULL;
+
+ NSOICFree(*NSGetConsumerId());
+ *NSGetConsumerId() = NULL;
+ }
}
bool NSIsStartedConsumer()
return * NSGetBoneIsStartedConsumer();
}
-NSProviderDiscoveredCallback * NSGetBoneDiscoverCb()
+NSProviderStateCallback * NSGetProviderChangedCb()
{
- static NSProviderDiscoveredCallback g_discoverCb = NULL;
+ static NSProviderStateCallback g_changedCb = NULL;
- return & g_discoverCb;
+ return & g_changedCb;
}
-void NSSetDiscoverProviderCb(NSProviderDiscoveredCallback cb)
+void NSSetProviderChangedCb(NSProviderStateCallback cb)
{
- * NSGetBoneDiscoverCb() = cb;
+ *(NSGetProviderChangedCb()) = cb;
}
-NSProviderDiscoveredCallback NSGetDiscoverCb()
+typedef struct
{
- return * NSGetBoneDiscoverCb();
-}
+ NSProvider * provider;
+ NSProviderState state;
+} NSProviderChangedData;
-void * NSDiscoveredProviderFunc(void * provider)
+void * NSProviderChangedFunc(void * obj)
{
- NSGetDiscoverCb()((NSProvider *) provider);
-
+ NS_LOG_V(DEBUG, "%s IN", __func__);
+ NSProviderChangedData * data = (NSProviderChangedData *) obj;
+ NSProviderStateCallback cb = *(NSGetProviderChangedCb());
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(cb, NULL,
+ {
+ NSRemoveProvider(data->provider);
+ NSOICFree(data);
+ });
+ NS_LOG(DEBUG, "Callback to user");
+ cb(data->provider, data->state);
+ NS_LOG(DEBUG, "Callback is Returned");
+
+ NSOICFree(data);
+ NS_LOG_V(DEBUG, "%s OUT", __func__);
return NULL;
}
-void NSDiscoveredProvider(NSProvider * provider)
+void NSProviderChanged(NSProvider * provider, NSProviderState response)
{
NS_VERIFY_NOT_NULL_V(provider);
- NSProvider * retProvider = (NSProvider *)NSCopyProvider((NSProvider_internal *)provider);
+ NSProvider * retProvider = NSCopyProvider((NSProvider_internal *) provider);
NS_VERIFY_NOT_NULL_V(retProvider);
- NSConsumerThread * thread = NSThreadInit(NSDiscoveredProviderFunc, (void *) retProvider);
- NS_VERIFY_NOT_NULL_V(thread);
-}
-
-NSSubscriptionAcceptedCallback * NSGetSubscriptionAcceptedCb()
-{
- static NSSubscriptionAcceptedCallback g_acceptCb = NULL;
+ NSProviderChangedData * data =
+ (NSProviderChangedData *)OICMalloc(sizeof(NSProviderChangedData));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(data, NSRemoveProvider(retProvider));
- return & g_acceptCb;
-}
+ data->provider = retProvider;
+ data->state = response;
-void NSSetSubscriptionAcceptedCb(NSSubscriptionAcceptedCallback cb)
-{
- *(NSGetSubscriptionAcceptedCb()) = cb;
-}
+ NSConsumerThread * thread = NSThreadInit(NSProviderChangedFunc, (void *) data);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(thread,
+ {
+ NSRemoveProvider(retProvider);
+ NSOICFree(data);
+ });
-void NSSubscriptionAccepted(NSProvider * provider)
-{
- (*(NSGetSubscriptionAcceptedCb()))(provider);
+ NSDestroyThreadHandle(thread);
+ NSOICFree(thread);
}
NSSyncInfoReceivedCallback * NSGetBoneNotificationSyncCb()
NSConsumerThread * thread = NSThreadInit(NSNotificationSyncFunc, (void *) retSync);
NS_VERIFY_NOT_NULL_V(thread);
+
+ NSDestroyThreadHandle(thread);
+ NSOICFree(thread);
}
NSMessageReceivedCallback * NSGetBoneMessagePostedCb()
{
NS_VERIFY_NOT_NULL_V(msg);
- NSMessage * retMsg = (NSMessage *)NSCopyMessage((NSMessage_consumer *)msg);
+ NSMessage * retMsg = NSCopyMessage(msg);
NS_VERIFY_NOT_NULL_V(retMsg);
NSConsumerThread * thread = NSThreadInit(NSMessagePostFunc, (void *) retMsg);
NS_VERIFY_NOT_NULL_V(thread);
+
+ NSDestroyThreadHandle(thread);
+ NSOICFree(thread);
}
NSTask * NSMakeTask(NSTaskType type, void * data)
return retTask;
}
-NSMessage_consumer * NSCopyMessage(NSMessage_consumer * msg)
+static NSMessage * NSCreateMessage_internal(uint64_t id, const char * providerId)
+{
+ NSMessage * retMsg = (NSMessage *)OICMalloc(sizeof(NSMessage));
+ NS_VERIFY_NOT_NULL(retMsg, NULL);
+
+ retMsg->messageId = id;
+ OICStrcpy(retMsg->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
+ retMsg->title = NULL;
+ retMsg->contentText = NULL;
+ retMsg->sourceName = NULL;
+ retMsg->topic = NULL;
+ retMsg->type = NS_MESSAGE_INFO;
+ retMsg->dateTime = NULL;
+ retMsg->ttl = 0;
+ retMsg->mediaContents = NULL;
+ retMsg->extraInfo = NULL;
+
+ return retMsg;
+}
+
+static OCRepPayload * NSGetExtraInfo(OCRepPayload * payload)
+{
+ NS_LOG(DEBUG, "get extra info");
+ OCRepPayload * extraInfo = OCRepPayloadCreate();
+ NS_VERIFY_NOT_NULL(extraInfo, NULL);
+ OCRepPayload * origin = OCRepPayloadClone(payload);
+
+ bool isFirstExtra = true;
+ OCRepPayloadValue * headValue = NULL;
+ OCRepPayloadValue * curValue = NULL;
+ OCRepPayloadValue * value = origin->values;
+ while(value)
+ {
+ if (NSIsExtraValue(value->name))
+ {
+ curValue = NSCopyPayloadValue(value);
+ NS_LOG_V(DEBUG, " key : %s", curValue->name);
+ if (isFirstExtra)
+ {
+ headValue = curValue;
+ extraInfo->values = headValue;
+ isFirstExtra = false;
+ }
+ else
+ {
+ headValue->next = curValue;
+ headValue = curValue;
+ }
+ curValue = NULL;
+ }
+ value = value->next;
+ }
+ OCRepPayloadDestroy(origin);
+
+
+ if (!isFirstExtra && extraInfo->values)
+ {
+ return extraInfo;
+ }
+ else
+ {
+ OCRepPayloadDestroy(extraInfo);
+ return NULL;
+ }
+}
+
+NSMessage * NSGetMessage(OCRepPayload * payload)
+{
+ NS_LOG(DEBUG, "get msg id");
+ uint64_t id = 0;
+ bool getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t *)&id);
+ NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+
+ NS_LOG(DEBUG, "get provider id");
+ char * pId = NULL;
+ getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, &pId);
+ NS_LOG_V (INFO_PRIVATE, "provider id: %s", pId);
+ NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+
+ NS_LOG(DEBUG, "create NSMessage");
+ NSMessage * retMsg = NSCreateMessage_internal(id, pId);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(retMsg, NULL, NSOICFree(pId));
+ NSOICFree(pId);
+
+ NS_LOG(DEBUG, "get msg optional field");
+ OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TITLE, &retMsg->title);
+ OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TEXT, &retMsg->contentText);
+ OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_SOURCE, &retMsg->sourceName);
+ OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TOPIC_NAME, &retMsg->topic);
+
+ OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_TYPE, (int64_t *)&retMsg->type);
+ OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_DATETIME, &retMsg->dateTime);
+ OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_TTL, (int64_t *)&retMsg->ttl);
+
+ char * icon = NULL;
+ OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_ICON_IMAGE, &icon);
+
+ if (icon && strlen(icon))
+ {
+ NSMediaContents * contents = (NSMediaContents *)OICMalloc(sizeof(NSMediaContents));
+ if (contents)
+ {
+ contents->iconImage = icon;
+ retMsg->mediaContents = contents;
+ }
+ else
+ {
+ NSOICFree(icon);
+ }
+ }
+
+ retMsg->extraInfo = NSGetExtraInfo(payload);
+
+ NS_LOG_V(DEBUG, "Msg ID : %lld", (long long int)retMsg->messageId);
+ NS_LOG_V(DEBUG, "Msg Title : %s", retMsg->title);
+ NS_LOG_V(DEBUG, "Msg Content : %s", retMsg->contentText);
+ NS_LOG_V(DEBUG, "Msg Source : %s", retMsg->sourceName);
+ NS_LOG_V(DEBUG, "Msg Topic : %s", retMsg->topic);
+ NS_LOG_V(DEBUG, "Msg Type : %d", retMsg->type);
+ NS_LOG_V(DEBUG, "Msg Date : %s", retMsg->dateTime);
+ NS_LOG_V(DEBUG, "Msg ttl : %lld", (long long int)retMsg->ttl);
+
+ return retMsg;
+}
+
+NSMessage * NSCopyMessage(NSMessage * msg)
{
NS_VERIFY_NOT_NULL(msg, NULL);
- NSMessage_consumer * newMsg = (NSMessage_consumer *)OICMalloc(sizeof(NSMessage_consumer));
+ NSMessage * newMsg = (NSMessage *)OICMalloc(sizeof(NSMessage));
NS_VERIFY_NOT_NULL(newMsg, NULL);
OICStrcpy(newMsg->providerId, NS_DEVICE_ID_LENGTH, msg->providerId);
- newMsg->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
- NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newMsg, NULL, NSOICFree(newMsg));
- memcpy(newMsg->i_addr, msg->i_addr, sizeof(OCDevAddr));
newMsg->messageId = msg->messageId;
newMsg->title = OICStrdup(msg->title);
newMsg->contentText = OICStrdup(msg->contentText);
newMsg->sourceName = OICStrdup(msg->sourceName);
+ newMsg->dateTime = OICStrdup(msg->dateTime);
newMsg->type = msg->type;
+ newMsg->ttl= msg->ttl;
+
+ newMsg->topic = NULL;
+ if (msg->topic && strlen(msg->topic) > 0)
+ {
+ newMsg->topic = OICStrdup(msg->topic);
+ }
+
+ newMsg->mediaContents = NULL;
+ if (msg->mediaContents)
+ {
+ newMsg->mediaContents = (NSMediaContents *)OICMalloc(sizeof(NSMediaContents));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(
+ newMsg->mediaContents, NULL, NSRemoveMessage(newMsg));
+ newMsg->mediaContents->iconImage =
+ (char *)OICMalloc(sizeof(char)*strlen(msg->mediaContents->iconImage) + 1);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(
+ newMsg->mediaContents->iconImage, NULL, NSRemoveMessage(newMsg));
+ memcpy(newMsg->mediaContents->iconImage, msg->mediaContents->iconImage,
+ strlen(msg->mediaContents->iconImage) + 1);
+ }
+
+ newMsg->extraInfo = NULL;
+ if (msg->extraInfo)
+ {
+ newMsg->extraInfo = OCRepPayloadClone(msg->extraInfo);
+ }
return newMsg;
}
-void NSRemoveMessage(NSMessage_consumer * msg)
+void NSRemoveMessage(NSMessage * msg)
{
NS_VERIFY_NOT_NULL_V(msg);
NSOICFree(msg->title);
NSOICFree(msg->contentText);
NSOICFree(msg->sourceName);
- NSOICFree(msg->i_addr);
+ NSOICFree(msg->dateTime);
+ NSOICFree(msg->topic);
+
+ if (msg->mediaContents)
+ {
+ NSOICFree(msg->mediaContents->iconImage);
+ }
+ NSOICFree(msg->mediaContents);
+
+ if (msg->extraInfo)
+ {
+ OCRepPayloadDestroy(msg->extraInfo);
+ msg->extraInfo = NULL;
+ }
NSOICFree(msg);
}
+void NSGetProviderPostClean(
+ char * pId, char * mUri, char * sUri, char * tUri, NSProviderConnectionInfo * connection)
+{
+ NSOICFree(pId);
+ NSOICFree(mUri);
+ NSOICFree(sUri);
+ NSOICFree(tUri);
+ NSRemoveConnections(connection);
+}
+
+NSProvider_internal * NSGetProvider(OCClientResponse * clientResponse)
+{
+ NS_LOG(DEBUG, "create NSProvider");
+ NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
+
+ OCRepPayloadPropType accepterType = OCREP_PROP_BOOL;
+
+ OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
+ OCRepPayloadValue * value = payload->values;
+ while (value)
+ {
+ NS_LOG_V(DEBUG, "Payload Key : %s", value->name);
+ NS_LOG_V(DEBUG, "Payload Type : %d", (int) value->type);
+ if (!strcmp(value->name, NS_ATTRIBUTE_POLICY))
+ {
+ accepterType = value->type;
+ }
+ value = value->next;
+ }
+
+ char * providerId = NULL;
+ char * messageUri = NULL;
+ char * syncUri = NULL;
+ char * topicUri = NULL;
+ bool bAccepter = 0;
+ int64_t iAccepter = 0;
+ NSProviderConnectionInfo * connection = NULL;
+
+ NS_LOG(DEBUG, "get information of accepter");
+ bool getResult = false;
+ if (accepterType == OCREP_PROP_BOOL)
+ {
+ getResult = OCRepPayloadGetPropBool(payload, NS_ATTRIBUTE_POLICY, & bAccepter);
+ }
+ else if (accepterType == OCREP_PROP_INT)
+ {
+ getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_POLICY, & iAccepter);
+ }
+ NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+
+ NS_LOG(DEBUG, "get provider ID");
+ getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, & providerId);
+ NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
+
+ NS_LOG(DEBUG, "get message URI");
+ getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_MESSAGE, & messageUri);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
+ NSGetProviderPostClean(providerId, messageUri, syncUri, topicUri, connection));
+
+ NS_LOG(DEBUG, "get sync URI");
+ getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_SYNC, & syncUri);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
+ NSGetProviderPostClean(providerId, messageUri, syncUri, topicUri, connection));
+
+ NS_LOG(DEBUG, "get topic URI");
+ getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TOPIC, & topicUri);
+
+ NS_LOG(DEBUG, "get provider connection information");
+ NS_VERIFY_NOT_NULL(clientResponse->addr, NULL);
+ connection = NSCreateProviderConnections(clientResponse->addr);
+ NS_VERIFY_NOT_NULL(connection, NULL);
+
+ NSProvider_internal * newProvider
+ = (NSProvider_internal *)OICMalloc(sizeof(NSProvider_internal));
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProvider, NULL,
+ NSGetProviderPostClean(providerId, messageUri, syncUri, topicUri, connection));
+
+ OICStrcpy(newProvider->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
+ NSOICFree(providerId);
+ newProvider->messageUri = messageUri;
+ newProvider->syncUri = syncUri;
+ newProvider->topicUri = NULL;
+ if (topicUri && strlen(topicUri) > 0)
+ {
+ newProvider->topicUri = topicUri;
+ }
+ if (accepterType == OCREP_PROP_BOOL)
+ {
+ newProvider->accessPolicy = (NSSelector)bAccepter;
+ }
+ else if (accepterType == OCREP_PROP_INT)
+ {
+ newProvider->accessPolicy = (NSSelector)iAccepter;
+ }
+
+ newProvider->connection = connection;
+ newProvider->topicLL = NULL;
+ newProvider->state = NS_DISCOVERED;
+
+ return newProvider;
+}
+
void NSRemoveConnections(NSProviderConnectionInfo * connections)
{
NS_VERIFY_NOT_NULL_V(connections);
tmp->messageHandle = NULL;
tmp->syncHandle = NULL;
NSOICFree(tmp->addr);
- tmp = tmp->next;
+ NSProviderConnectionInfo * next = tmp->next;
+ NSOICFree(tmp);
+ tmp = next;
}
-
- NSOICFree(connections);
}
NSProviderConnectionInfo * NSCreateProviderConnections(OCDevAddr * inAddr)
NSProviderConnectionInfo * tmp = conn;
NSProviderConnectionInfo * retInfo = NSCreateProviderConnections(tmp->addr);
+ NS_VERIFY_NOT_NULL(retInfo, NULL);
+ retInfo->messageHandle = tmp->messageHandle;
+ retInfo->syncHandle = tmp->syncHandle;
+ retInfo->isCloudConnection = tmp->isCloudConnection;
+ retInfo->isSubscribing = tmp->isSubscribing;
+
tmp = tmp->next;
NSProviderConnectionInfo * copyInfo = retInfo;
while(tmp)
{
- copyInfo = NSCreateProviderConnections(tmp->addr);
- NS_VERIFY_NOT_NULL(copyInfo, NULL);
+ NSProviderConnectionInfo * tmpInfo = NSCreateProviderConnections(tmp->addr);
+ NS_VERIFY_NOT_NULL(tmpInfo, NULL);
- copyInfo->messageHandle = tmp->messageHandle;
- copyInfo->syncHandle = tmp->syncHandle;
- copyInfo->isCloudConnection = tmp->isCloudConnection;
- copyInfo->isSubscribing = tmp->isSubscribing;
+ tmpInfo->messageHandle = tmp->messageHandle;
+ tmpInfo->syncHandle = tmp->syncHandle;
+ tmpInfo->isCloudConnection = tmp->isCloudConnection;
+ tmpInfo->isSubscribing = tmp->isSubscribing;
tmp = tmp->next;
- copyInfo = copyInfo->next;
+ copyInfo->next = tmpInfo;
+ copyInfo = tmpInfo;
}
return retInfo;
}
-NSProvider_internal * NSCopyProvider(NSProvider_internal * prov)
+void NSRemoveTopicNode(NSTopicLL * topicNode)
+{
+ NS_VERIFY_NOT_NULL_V(topicNode);
+
+ NSOICFree(topicNode->topicName);
+ topicNode->next = NULL;
+
+ NSOICFree(topicNode);
+}
+
+NSTopicLL * NSCopyTopicNode(NSTopicLL * topicNode)
+{
+ NS_VERIFY_NOT_NULL(topicNode, NULL);
+
+ NSTopicLL * newTopicNode = (NSTopicLL *)OICMalloc(sizeof(NSTopicLL));
+ NS_VERIFY_NOT_NULL(newTopicNode, NULL);
+
+ newTopicNode->topicName = OICStrdup(topicNode->topicName);
+ newTopicNode->state = topicNode->state;
+ newTopicNode->next = NULL;
+
+ return newTopicNode;
+}
+
+NSResult NSInsertTopicNode(NSTopicLL * topicHead, NSTopicLL * topicNode)
+{
+ NS_VERIFY_NOT_NULL(topicHead, NS_ERROR);
+ NS_VERIFY_NOT_NULL(topicNode, NS_ERROR);
+
+ NSTopicLL * iter = topicHead;
+ NSTopicLL * prev = NULL;
+
+ while (iter)
+ {
+ prev = iter;
+ iter = (NSTopicLL *) iter->next;
+ }
+
+ prev->next = topicNode;
+ topicNode->next = NULL;
+
+ return NS_OK;
+}
+
+void NSRemoveTopicLL(NSTopicLL * topicHead)
+{
+ NS_VERIFY_NOT_NULL_V(topicHead);
+
+ NSTopicLL * iter = topicHead;
+ NSTopicLL * following = NULL;
+
+ while (iter)
+ {
+ following = iter->next;
+
+ NSRemoveTopicNode(iter);
+
+ iter = following;
+ }
+}
+
+NSTopicLL * NSCopyTopicLL(NSTopicLL * topicHead)
+{
+ NS_VERIFY_NOT_NULL(topicHead, NULL);
+
+ NSTopicLL * iter = topicHead;
+
+ NS_LOG_V(DEBUG, "[NSCopyTopicLL] Name:%s\t State:%d", iter->topicName, iter->state);
+ NSTopicLL * newTopicHead = NSCopyTopicNode(iter);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicHead, NULL, NSRemoveTopicLL(newTopicHead));
+
+ iter = (NSTopicLL *) iter->next;
+
+ while (iter)
+ {
+ NS_LOG_V(DEBUG, "[NSCopyTopicLL] Name:%s\t State:%d", iter->topicName, iter->state);
+ NSTopicLL * newTopicNode = NSCopyTopicNode(iter);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicNode, NULL, NSRemoveTopicLL(newTopicHead));
+
+ NSResult ret = NSInsertTopicNode(newTopicHead, newTopicNode);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *)1 : NULL,
+ NULL, NSRemoveTopicLL(newTopicHead));
+
+ iter = (NSTopicLL *) iter->next;
+ }
+
+ return newTopicHead;
+}
+
+void NSCopyProviderPostClean(
+ NSProviderConnectionInfo * connections, NSProvider_internal * provider)
+{
+ NSRemoveConnections(connections);
+ NSOICFree(provider);
+}
+
+NSProvider_internal * NSCopyProvider_internal(NSProvider_internal * prov)
{
NS_VERIFY_NOT_NULL(prov, NULL);
NSProviderConnectionInfo * connections = NSCopyProviderConnections(prov->connection);
NS_VERIFY_NOT_NULL(connections, NULL);
- NSProvider_internal * newProv = (NSProvider_internal *)OICMalloc(sizeof(NSProvider_internal));
+ NSProvider_internal * newProv = (NSProvider_internal *) OICMalloc(sizeof(NSProvider_internal));
NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProv, NULL, NSRemoveConnections(connections));
+ newProv->topicLL = NULL;
+
+ if (prov->topicLL)
+ {
+ NSTopicLL * newTopicLL = NSCopyTopicLL(prov->topicLL);
+ NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicLL, NULL,
+ NSCopyProviderPostClean(connections, newProv));
+
+ newProv->topicLL = newTopicLL;
+ }
+
newProv->connection = connections;
OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
newProv->messageUri = OICStrdup(prov->messageUri);
newProv->syncUri = OICStrdup(prov->syncUri);
+ newProv->topicUri = OICStrdup(prov->topicUri);
newProv->accessPolicy = prov->accessPolicy;
+ newProv->state = prov->state;
return newProv;
}
-void NSRemoveProvider(NSProvider_internal * prov)
+
+NSProvider * NSCopyProvider(NSProvider_internal * prov)
{
- NS_VERIFY_NOT_NULL_V(prov);
+ NS_VERIFY_NOT_NULL(prov, NULL);
+
+ NSProvider * newProv = (NSProvider *) OICMalloc(sizeof(NSProvider));
+ NS_VERIFY_NOT_NULL(newProv, NULL);
+
+ OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
+
+ return newProv;
+}
+
+void NSRemoveProvider_internal(void * data)
+{
+ NS_VERIFY_NOT_NULL_V(data);
+
+ NSProvider_internal * prov = (NSProvider_internal *) data;
NSOICFree(prov->messageUri);
NSOICFree(prov->syncUri);
+ NSOICFree(prov->topicUri);
NSRemoveConnections(prov->connection);
+ if (prov->topicLL)
+ {
+ NSRemoveTopicLL(prov->topicLL);
+ }
NSOICFree(prov);
}
+void NSRemoveProvider(NSProvider * prov)
+{
+ NS_VERIFY_NOT_NULL_V(prov);
+ NSOICFree(prov);
+}
+
OCStackResult NSInvokeRequest(OCDoHandle * handle,
OCMethod method, const OCDevAddr * addr,
const char * queryUrl, OCPayload * payload,
- void * callbackFunc, void * callbackData, OCConnectivityType type)
+ void * callbackFunc, void * callbackData,
+ OCClientContextDeleter cd, OCConnectivityType type)
{
int mutexRet = pthread_mutex_lock(*(NSGetStackMutex()));
NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
- OCCallbackData cbdata = { 0, };
+ OCCallbackData cbdata = { NULL, NULL, NULL };
cbdata.cb = callbackFunc;
cbdata.context = callbackData;
- cbdata.cd = NULL;
+ cbdata.cd = cd;
OCStackResult ret = OCDoResource(handle, method, queryUrl, addr,
payload, type, NS_QOS, &cbdata, NULL, 0);
return ret;
}
-bool NSOCResultToSuccess(OCStackResult ret)
+bool NSIsExtraValue(const char * name)
{
- switch (ret)
+ if (!strcmp(name, NS_ATTRIBUTE_MESSAGE_ID) ||
+ !strcmp(name, NS_ATTRIBUTE_PROVIDER_ID) ||
+ !strcmp(name, NS_ATTRIBUTE_TITLE) ||
+ !strcmp(name, NS_ATTRIBUTE_TEXT) ||
+ !strcmp(name, NS_ATTRIBUTE_SOURCE) ||
+ !strcmp(name, NS_ATTRIBUTE_TOPIC_NAME) ||
+ !strcmp(name, NS_ATTRIBUTE_TYPE) ||
+ !strcmp(name, NS_ATTRIBUTE_DATETIME) ||
+ !strcmp(name, NS_ATTRIBUTE_TTL) ||
+ !strcmp(name, NS_ATTRIBUTE_ICON_IMAGE))
{
- case OC_STACK_OK:
- case OC_STACK_RESOURCE_CREATED:
- case OC_STACK_RESOURCE_DELETED:
- case OC_STACK_CONTINUE:
- case OC_STACK_RESOURCE_CHANGED:
- return true;
+ return false;
+ }
+
+ return true;
+}
+
+
+void NSCopyPayloadValueArray(OCRepPayloadValue* dest, OCRepPayloadValue* source)
+{
+ NS_VERIFY_NOT_NULL_V(source);
+
+ size_t dimTotal = calcDimTotal(source->arr.dimensions);
+ switch(source->arr.type)
+ {
+ case OCREP_PROP_INT:
+ dest->arr.iArray = (int64_t*)OICMalloc(dimTotal * sizeof(int64_t));
+ NS_VERIFY_NOT_NULL_V(dest->arr.iArray);
+ memcpy(dest->arr.iArray, source->arr.iArray, dimTotal * sizeof(int64_t));
+ break;
+ case OCREP_PROP_DOUBLE:
+ dest->arr.dArray = (double*)OICMalloc(dimTotal * sizeof(double));
+ NS_VERIFY_NOT_NULL_V(dest->arr.dArray);
+ memcpy(dest->arr.dArray, source->arr.dArray, dimTotal * sizeof(double));
+ break;
+ case OCREP_PROP_BOOL:
+ dest->arr.bArray = (bool*)OICMalloc(dimTotal * sizeof(bool));
+ NS_VERIFY_NOT_NULL_V(dest->arr.bArray);
+ memcpy(dest->arr.bArray, source->arr.bArray, dimTotal * sizeof(bool));
+ break;
+ case OCREP_PROP_STRING:
+ dest->arr.strArray = (char**)OICMalloc(dimTotal * sizeof(char*));
+ NS_VERIFY_NOT_NULL_V(dest->arr.strArray);
+ for(size_t i = 0; i < dimTotal; ++i)
+ {
+ dest->arr.strArray[i] = OICStrdup(source->arr.strArray[i]);
+ }
+ break;
+ case OCREP_PROP_OBJECT:
+ dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
+ NS_VERIFY_NOT_NULL_V(dest->arr.objArray);
+ for(size_t i = 0; i < dimTotal; ++i)
+ {
+ dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
+ }
+ break;
+ case OCREP_PROP_ARRAY:
+ dest->arr.objArray = (OCRepPayload**)OICMalloc(dimTotal * sizeof(OCRepPayload*));
+ NS_VERIFY_NOT_NULL_V(dest->arr.objArray);
+ for(size_t i = 0; i < dimTotal; ++i)
+ {
+ dest->arr.objArray[i] = OCRepPayloadClone(source->arr.objArray[i]);
+ }
+ break;
+ case OCREP_PROP_BYTE_STRING:
+ dest->arr.ocByteStrArray = (OCByteString*)OICMalloc(dimTotal * sizeof(OCByteString));
+ NS_VERIFY_NOT_NULL_V(dest->arr.ocByteStrArray);
+ for (size_t i = 0; i < dimTotal; ++i)
+ {
+ OCByteStringCopy(&dest->arr.ocByteStrArray[i], &source->arr.ocByteStrArray[i]);
+ NS_VERIFY_NOT_NULL_V(dest->arr.ocByteStrArray[i].bytes);
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+OCRepPayloadValue * NSCopyPayloadValue(OCRepPayloadValue * value)
+{
+ OCRepPayloadValue * retValue = (OCRepPayloadValue *)OICMalloc(sizeof(OCRepPayloadValue));
+ NS_VERIFY_NOT_NULL(retValue, NULL);
+
+ * retValue = * value;
+ retValue->next = NULL;
+ retValue->name = OICStrdup(value->name);
+
+ switch(value->type)
+ {
+ case OCREP_PROP_STRING:
+ retValue->str = OICStrdup(value->str);
+ break;
+ case OCREP_PROP_BYTE_STRING:
+ retValue->ocByteStr.bytes = (uint8_t * )OICMalloc(value->ocByteStr.len * sizeof(uint8_t));
+ NS_VERIFY_NOT_NULL(retValue->ocByteStr.bytes, NULL);
+ retValue->ocByteStr.len = value->ocByteStr.len;
+ memcpy(retValue->ocByteStr.bytes, value->ocByteStr.bytes, retValue->ocByteStr.len);
+ break;
+ case OCREP_PROP_OBJECT:
+ retValue->obj = OCRepPayloadClone(value->obj);
+ break;
+ case OCREP_PROP_ARRAY:
+ NSCopyPayloadValueArray(retValue, value);
+ break;
default:
- return false;
+ break;
}
+
+ return retValue;
}