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 "NSConsumerCommunication.h"
23 #include "NSConstants.h"
25 #include "NSConsumerCommon.h"
26 #include "oic_malloc.h"
27 #include "oic_string.h"
28 #include "ocpayload.h"
30 #define NS_SYNC_URI "/notification/sync"
32 NSSyncInfo * NSCreateSyncInfo_consumer(uint64_t msgId, const char * providerId, NSSyncType state);
34 NSSyncInfo * NSGetSyncInfoc(OCClientResponse * clientResponse);
35 NSTopicLL * NSGetTopicLL(OCClientResponse * clientResponse);
37 char * NSGetCloudUri(const char * providerId, char * uri);
39 NSResult NSUpdateObserveResult(NSProvider_internal * prov, char * query)
43 NSProvider_internal * taskProvider = NSCopyProvider_internal(prov);
44 NSTask * task = NSMakeTask(TASK_CONSUMER_SENT_REQ_OBSERVE, (void *) taskProvider);
45 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task,
46 NS_ERROR, NSRemoveProvider_internal(taskProvider));
48 NSConsumerPushEvent(task);
53 NSResult NSConsumerSubscribeProvider(NSProvider * provider)
55 NSProvider_internal * provider_internal = (NSProvider_internal *) provider;
56 NS_VERIFY_NOT_NULL(provider_internal, NS_ERROR);
58 NSProviderConnectionInfo * connections = provider_internal->connection;
61 if (connections->isSubscribing == true)
63 connections = connections->next;
67 char * msgUri = OICStrdup(provider_internal->messageUri);
68 NS_VERIFY_NOT_NULL(msgUri, NS_ERROR);
69 char * syncUri = OICStrdup(provider_internal->syncUri);
70 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(syncUri, NS_ERROR, NSOICFree(msgUri));
72 OCConnectivityType type = CT_DEFAULT;
73 if (connections->addr->adapter == OC_ADAPTER_TCP)
75 type = CT_ADAPTER_TCP;
76 if (connections->isCloudConnection == true)
78 msgUri = NSGetCloudUri(provider_internal->providerId, msgUri);
79 NS_VERIFY_NOT_NULL(msgUri, NS_ERROR);
80 syncUri = NSGetCloudUri(provider_internal->providerId, syncUri);
81 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(syncUri, NS_ERROR, NSOICFree(msgUri));
85 NS_LOG_V(INFO_PRIVATE, "subscribe to %s:%d", connections->addr->addr, connections->addr->port);
87 NS_LOG(DEBUG, "get subscribe message query");
89 query = NSMakeRequestUriWithConsumerId(msgUri);
90 NS_VERIFY_NOT_NULL(query, NS_ERROR);
92 NS_LOG(DEBUG, "subscribe message");
93 NS_LOG_V(DEBUG, "subscribe query : %s", query);
94 OCStackResult ret = NSInvokeRequest(&(connections->messageHandle),
95 OC_REST_OBSERVE, connections->addr, query, NULL,
96 NSConsumerMessageListener, NULL, NULL, type);
97 NS_VERIFY_STACK_SUCCESS_WITH_POST_CLEANING(NSOCResultToSuccess(ret),
98 NS_ERROR, NSUpdateObserveResult(provider_internal, query));
102 NS_LOG(DEBUG, "get subscribe sync query");
103 query = NSMakeRequestUriWithConsumerId(syncUri);
104 NS_VERIFY_NOT_NULL(query, NS_ERROR);
106 NS_LOG(DEBUG, "subscribe sync");
107 NS_LOG_V(DEBUG, "subscribe query : %s", query);
108 ret = NSInvokeRequest(&(connections->syncHandle),
109 OC_REST_OBSERVE, connections->addr, query, NULL,
110 NSConsumerSyncInfoListener, NULL, NULL, type);
111 NS_VERIFY_STACK_SUCCESS_WITH_POST_CLEANING(NSOCResultToSuccess(ret),
112 NS_ERROR, NSUpdateObserveResult(provider_internal, query));
116 connections->isSubscribing = true;
118 connections = connections->next;
121 NSProvider_internal * taskProvider = NSCopyProvider_internal(provider_internal);
122 NSTask * task = NSMakeTask(TASK_CONSUMER_SENT_REQ_OBSERVE, (void *) taskProvider);
123 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task,
124 NS_ERROR, NSRemoveProvider_internal(taskProvider));
126 NSConsumerPushEvent(task);
131 OCStackApplicationResult NSConsumerCheckPostResult(
132 void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
137 NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
138 NS_VERIFY_STACK_SUCCESS(
139 NSOCResultToSuccess(clientResponse->result), OC_STACK_KEEP_TRANSACTION);
141 return OC_STACK_KEEP_TRANSACTION;
144 void NSRemoveSyncInfoObj(NSSyncInfo * sync)
149 OCStackApplicationResult NSConsumerSyncInfoListener(
150 void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
155 NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
156 NS_VERIFY_STACK_SUCCESS(
157 NSOCResultToSuccess(clientResponse->result), OC_STACK_KEEP_TRANSACTION);
159 NS_LOG(DEBUG, "get NSSyncInfo");
160 NSSyncInfo * newSync = NSGetSyncInfoc(clientResponse);
161 NS_VERIFY_NOT_NULL(newSync, OC_STACK_KEEP_TRANSACTION);
163 NSTaskType taskType = TASK_RECV_SYNCINFO;
165 NS_LOG(DEBUG, "build NSTask");
166 NSTask * task = NSMakeTask(taskType, (void *) newSync);
167 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task,
168 OC_STACK_KEEP_TRANSACTION, NSRemoveSyncInfoObj(newSync));
170 NSConsumerPushEvent(task);
172 return OC_STACK_KEEP_TRANSACTION;
175 OCStackApplicationResult NSConsumerMessageListener(
176 void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
181 NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
182 NS_VERIFY_STACK_SUCCESS(NSOCResultToSuccess(clientResponse->result), OC_STACK_KEEP_TRANSACTION);
184 NS_LOG(DEBUG, "build NSMessage");
185 NSMessage * newNoti = NSGetMessage((OCRepPayload *) clientResponse->payload);
186 NS_VERIFY_NOT_NULL(newNoti, OC_STACK_KEEP_TRANSACTION);
188 NSTaskType type = TASK_CONSUMER_RECV_MESSAGE;
190 if (newNoti->messageId == NS_ALLOW || newNoti->messageId == NS_DENY)
192 NS_LOG(DEBUG, "Receive subscribe result");
193 type = TASK_CONSUMER_RECV_PROVIDER_CHANGED;
195 else if (newNoti->messageId == NS_TOPIC)
197 NS_LOG(DEBUG, "Receive Topic change");
198 type = TASK_CONSUMER_REQ_TOPIC_URI;
202 NS_LOG(DEBUG, "Receive new message");
205 NS_LOG(DEBUG, "build NSTask");
206 NSTask * task = NSMakeTask(type, (void *) newNoti);
207 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveMessage(newNoti));
209 NSConsumerPushEvent(task);
211 return OC_STACK_KEEP_TRANSACTION;
214 void NSGetMessagePostClean(char * pId, OCDevAddr * addr)
220 NSSyncInfo * NSGetSyncInfoc(OCClientResponse * clientResponse)
222 NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
224 OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
226 NS_LOG(DEBUG, "get msg id");
228 bool getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t *)&id);
229 NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
231 NS_LOG(DEBUG, "get provider id");
233 getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, &pId);
234 NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
236 NS_LOG(DEBUG, "get state");
238 getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_STATE, & state);
239 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL,
240 NULL, NSOICFree(pId));
242 NS_LOG(DEBUG, "create NSSyncInfo");
243 NSSyncInfo * retSync = NSCreateSyncInfo_consumer(id, pId, (NSSyncType)state);
245 NS_VERIFY_NOT_NULL(retSync, NULL);
247 NS_LOG_V(DEBUG, "Sync ID : %lld", (long long int)retSync->messageId);
248 NS_LOG_V(DEBUG, "Sync State : %d", (int) retSync->state);
249 NS_LOG_V(INFO_PRIVATE, "Sync Provider ID : %s", retSync->providerId);
254 NSSyncInfo * NSCreateSyncInfo_consumer(uint64_t msgId, const char * providerId, NSSyncType state)
256 NS_VERIFY_NOT_NULL(providerId, NULL);
258 NSSyncInfo * retSync = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
259 NS_VERIFY_NOT_NULL(retSync, NULL);
261 retSync->messageId = msgId;
262 retSync->state = state;
263 OICStrcpy(retSync->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
268 OCStackResult NSSendSyncInfo(NSSyncInfo * syncInfo, OCDevAddr * addr)
270 NS_VERIFY_NOT_NULL(syncInfo, OC_STACK_ERROR);
271 NS_VERIFY_NOT_NULL(addr, OC_STACK_ERROR);
273 OCRepPayload * payload = OCRepPayloadCreate();
274 NS_VERIFY_NOT_NULL(payload, OC_STACK_ERROR);
276 OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t)syncInfo->messageId);
277 OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_STATE, syncInfo->state);
278 OCRepPayloadSetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, syncInfo->providerId);
280 char * uri = (char*)OICStrdup(NS_SYNC_URI);
281 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(uri, OC_STACK_ERROR, OCRepPayloadDestroy(payload));
283 OCConnectivityType type = CT_DEFAULT;
284 if(addr->adapter == OC_ADAPTER_TCP)
286 type = CT_ADAPTER_TCP;
287 uri = NSGetCloudUri(syncInfo->providerId, uri);
288 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(uri, OC_STACK_ERROR, OCRepPayloadDestroy(payload));
291 OCStackResult ret = NSInvokeRequest(NULL, OC_REST_POST, addr,
292 uri, (OCPayload*)payload,
293 NSConsumerCheckPostResult, NULL, NULL, type);
299 char * NSGetCloudUri(const char * providerId, char * uri)
301 size_t uriLen = NS_DEVICE_ID_LENGTH + 1 + strlen(uri) + 1 + 10;
302 char * retUri = (char *)OICMalloc(uriLen);
303 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(retUri, NULL, NSOICFree(uri));
305 snprintf(retUri, uriLen, "/oic/route/%s%s", providerId, uri);
307 NS_LOG_V(DEBUG, "Cloud uri : %s", retUri);
312 void NSConsumerCommunicationTaskProcessing(NSTask * task)
314 NS_VERIFY_NOT_NULL_V(task);
316 NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
317 if (task->taskType == TASK_CONSUMER_REQ_SUBSCRIBE)
319 NS_VERIFY_NOT_NULL_V(task->taskData);
320 NS_LOG(DEBUG, "Request Subscribe");
321 NSResult ret = NSConsumerSubscribeProvider((NSProvider *)task->taskData);
322 NSRemoveProvider_internal((void *) task->taskData);
323 NS_VERIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
325 else if (task->taskType == TASK_SEND_SYNCINFO)
327 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(task->taskData, NSOICFree(task));
328 NSSyncInfo_internal * syncInfo = (NSSyncInfo_internal *)task->taskData;
329 NSProviderConnectionInfo * info = syncInfo->connection;
333 OCStackResult ret = NSSendSyncInfo((NSSyncInfo *)(task->taskData), info->addr);
334 if (ret != OC_STACK_OK)
336 NS_LOG_V(ERROR, "send sync info fail : %d", info->addr->adapter);
342 NSRemoveConnections(syncInfo->connection);
345 else if (task->taskType == TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL)
347 NSProvider_internal * provider = (NSProvider_internal *)task->taskData;
348 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(provider,
350 NSRemoveProvider_internal(provider);
354 NSProviderConnectionInfo * connections = provider->connection;
357 if (connections->isSubscribing == false)
359 NS_LOG_V(INFO_PRIVATE, "unsubscribed to %s:%d",
360 connections->addr->addr, connections->addr->port);
361 connections = connections->next;
364 NS_LOG_V(INFO_PRIVATE, "cancel subscribe to %s:%d",
365 connections->addr->addr, connections->addr->port);
366 OCCancel(connections->messageHandle, NS_QOS, NULL, 0);
367 OCCancel(connections->syncHandle, NS_QOS, NULL, 0);
368 connections->messageHandle = NULL;
369 connections->syncHandle = NULL;
370 connections->isSubscribing = false;
371 connections = connections->next;
374 NSRemoveProvider_internal(provider);
376 else if (task->taskType == TASK_CONSUMER_REQ_TOPIC_LIST)
378 NSProvider_internal * provider = NSCopyProvider_internal(task->taskData);
379 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(provider,
381 NSRemoveProvider_internal((void *) task->taskData);
384 NSRemoveProvider_internal((NSProvider_internal *)task->taskData);
386 NSProviderConnectionInfo * connections = provider->connection;
387 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(connections,
389 NSRemoveProvider_internal((void *) provider);
393 char * topicUri = OICStrdup(provider->topicUri);
394 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(topicUri,
396 NSRemoveProvider_internal((void *) provider);
400 OCConnectivityType type = CT_DEFAULT;
401 if (connections->addr->adapter == OC_ADAPTER_TCP)
403 type = CT_ADAPTER_TCP;
404 if (connections->isCloudConnection == true)
406 topicUri = NSGetCloudUri(provider->providerId, topicUri);
410 NS_LOG(DEBUG, "get topic query");
411 char * query = NSMakeRequestUriWithConsumerId(topicUri);
412 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(query,
414 NSRemoveProvider_internal((void *) provider);
417 NS_LOG_V(DEBUG, "topic query : %s", query);
419 OCStackResult ret = NSInvokeRequest(NULL, OC_REST_GET, connections->addr,
420 query, NULL, NSIntrospectTopic, (void *) provider,
421 NSRemoveProvider_internal, type);
422 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(NSOCResultToSuccess(ret) == true ? (void *) 1 : NULL,
424 NSRemoveProvider_internal((void *) provider);
431 else if (task->taskType == TASK_CONSUMER_SELECT_TOPIC_LIST)
433 NSProvider_internal * provider = (NSProvider_internal *)task->taskData;
434 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(provider,
436 NSRemoveProvider_internal(provider);
440 NSProviderConnectionInfo * connections = provider->connection;
441 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(connections,
443 NSRemoveProvider_internal(provider);
447 OCRepPayload * payload = OCRepPayloadCreate();
448 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(payload,
450 NSRemoveProvider_internal(provider);
454 NSTopicLL * topicLL = provider->topicLL;
455 NSTopicLL * iter = topicLL;
460 NS_LOG_V(DEBUG, "[%d] Topic Name:%s\tTopic State:%d",
461 topicLLSize, iter->topicName, iter->state);
462 iter = (NSTopicLL *) iter->next;
465 OCRepPayloadSetPropString(payload, NS_ATTRIBUTE_CONSUMER_ID, *NSGetConsumerId());
466 NS_LOG_V(INFO_PRIVATE, "NS_ATTRIBUTE_CONSUMER_ID: %s", *NSGetConsumerId());
470 NS_LOG_V(DEBUG, "DimensionSize: %d", topicLLSize);
472 OCRepPayload ** topicPayload = NULL;
475 topicPayload = (OCRepPayload **) OICMalloc(sizeof(OCRepPayload *)*topicLLSize);
476 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(topicPayload,
478 OCRepPayloadDestroy(payload);
479 NSRemoveProvider_internal(provider);
483 while (iter || iterSize < topicLLSize)
485 topicPayload[iterSize] = OCRepPayloadCreate();
486 OCRepPayloadSetPropString(topicPayload[iterSize], NS_ATTRIBUTE_TOPIC_NAME,
488 OCRepPayloadSetPropInt(topicPayload[iterSize], NS_ATTRIBUTE_TOPIC_SELECTION,
490 NS_LOG_V(DEBUG, "NS_ATTRIBUTE_TOPIC_NAME: %s", iter->topicName);
491 NS_LOG_V(DEBUG, "NS_ATTRIBUTE_TOPIC_SELECTION: %d", iter->state);
495 size_t dimensions[3] = {topicLLSize, 0, 0};
497 OCRepPayloadSetPropObjectArrayAsOwner(payload, NS_ATTRIBUTE_TOPIC_LIST,
498 topicPayload, dimensions);
502 OCRepPayloadSetNull(payload, NS_ATTRIBUTE_TOPIC_LIST);
505 char * topicUri = OICStrdup(provider->topicUri);
506 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(topicUri,
508 OCRepPayloadDestroy(payload);
509 NSRemoveProvider_internal(provider);
513 OCConnectivityType type = CT_DEFAULT;
514 if (connections->addr->adapter == OC_ADAPTER_TCP)
516 type = CT_ADAPTER_TCP;
517 if (connections->isCloudConnection == true)
519 topicUri = NSGetCloudUri(provider->providerId, topicUri);
523 NS_LOG(DEBUG, "get topic query");
525 query = NSMakeRequestUriWithConsumerId(topicUri);
526 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(query,
529 OCRepPayloadDestroy(payload);
530 NSRemoveProvider_internal(provider);
533 NS_LOG_V(DEBUG, "topic query : %s", query);
535 OCStackResult ret = NSInvokeRequest(NULL, OC_REST_POST, connections->addr,
536 query, (OCPayload*)payload, NSConsumerCheckPostResult,
538 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING_V(
539 NSOCResultToSuccess(ret) == true ? (void *) 1 : NULL,
543 NSRemoveProvider_internal(provider);
547 NSRemoveProvider_internal(provider);
553 NS_LOG(ERROR, "Unknown type message");
559 NSTopicLL * NSGetTopicLL(OCClientResponse * clientResponse)
561 NS_LOG(DEBUG, "create NSTopicLL");
562 NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
564 OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
565 OCRepPayloadValue * value = payload->values;
568 NS_LOG_V(DEBUG, "Payload Key : %s", value->name);
572 char * consumerId = NULL;
573 OCRepPayload ** topicLLPayload = NULL;
575 NS_LOG(DEBUG, "get information of consumerId");
577 bool getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_CONSUMER_ID, & consumerId);
578 NSOICFree(consumerId);
580 OCRepPayloadValue * payloadValue = NULL;
581 payloadValue = NSPayloadFindValue(payload, NS_ATTRIBUTE_TOPIC_LIST);
582 NS_VERIFY_NOT_NULL(payloadValue, NULL);
584 size_t dimensionSize = calcDimTotal(payloadValue->arr.dimensions);
585 NS_LOG_V(DEBUG, "DimensionSize: %d", (int)dimensionSize);
587 if (dimensionSize == 0 || payloadValue->type == OCREP_PROP_NULL ||
588 payloadValue->arr.objArray == NULL)
590 NS_LOG(DEBUG, "No TopicLL");
594 topicLLPayload = payloadValue->arr.objArray;
596 NSTopicLL * topicLL = NULL;
597 for (int i = 0; i < (int)dimensionSize; i++)
599 char * topicName = NULL;
602 NSTopicLL * topicNode = (NSTopicLL *) OICMalloc(sizeof(NSTopicLL));
603 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(topicNode, NULL, NSRemoveTopicLL(topicLL));
605 NS_LOG(DEBUG, "get topic selection");
606 getResult = OCRepPayloadGetPropInt(topicLLPayload[i],
607 NS_ATTRIBUTE_TOPIC_SELECTION, & state);
608 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL,
609 NULL, NSRemoveTopicLL(topicLL));
611 NS_LOG(DEBUG, "get topic name");
612 getResult = OCRepPayloadGetPropString(topicLLPayload[i],
613 NS_ATTRIBUTE_TOPIC_NAME, & topicName);
614 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL,
615 NULL, NSRemoveTopicLL(topicLL));
616 NS_LOG_V(DEBUG, "topic name: %s", topicName);
617 NS_LOG_V(DEBUG, "topic selection: %d", (int)state);
619 topicNode->topicName = topicName;
620 topicNode->state = state;
625 topicNode->next = NULL;
629 NSResult ret = NSInsertTopicNode(topicLL, topicNode);
630 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(ret == NS_OK ? (void *)1 : NULL,
631 NULL, NSRemoveTopicLL(topicLL));
637 OCStackApplicationResult NSIntrospectTopic(
638 void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
642 NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
643 NS_VERIFY_STACK_SUCCESS(NSOCResultToSuccess(clientResponse->result),
644 OC_STACK_KEEP_TRANSACTION)
646 NS_LOG_V(INFO_PRIVATE, "GET response income : %s:%d",
647 clientResponse->devAddr.addr, clientResponse->devAddr.port);
648 NS_LOG_V(DEBUG, "GET response result : %d",
649 clientResponse->result);
650 NS_LOG_V(DEBUG, "GET response sequenceNum : %d",
651 clientResponse->sequenceNumber);
652 NS_LOG_V(DEBUG, "GET response resource uri : %s",
653 clientResponse->resourceUri);
654 NS_LOG_V(DEBUG, "GET response Transport Type : %d",
655 clientResponse->devAddr.adapter);
657 NSTopicLL * newTopicLL = NSGetTopicLL(clientResponse);
659 NSProvider_internal * provider = NSCopyProvider_internal((NSProvider_internal *) ctx);
660 NS_VERIFY_NOT_NULL(provider, OC_STACK_KEEP_TRANSACTION);
661 NSRemoveTopicLL(provider->topicLL);
662 provider->topicLL = NSCopyTopicLL(newTopicLL);
663 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(provider->topicLL, OC_STACK_KEEP_TRANSACTION,
664 NSRemoveProvider_internal((void *) provider));
666 NS_LOG(DEBUG, "build NSTask");
667 NSTask * task = NSMakeTask(TASK_CONSUMER_RECV_TOPIC_LIST, (void *) provider);
668 NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProvider_internal(provider));
670 NSConsumerPushEvent(task);
671 NSRemoveTopicLL(newTopicLL);
673 return OC_STACK_KEEP_TRANSACTION;