service/notification/src/consumer/NSConsumerCommon.c

   1 //******************************************************************
   2 //
   3 // Copyright 2016 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   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
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  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.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "NSConsumerCommon.h"
  22 #include "NSConstants.h"
  23 #include "NSThread.h"
  24 #include "oic_malloc.h"
  25 #include "oic_string.h"
  26
  27 #include <pthread.h>
  28
  29 #define NS_QUERY_CONSUMER_ID "consumerid"
  30
  31 pthread_mutex_t ** NSGetStackMutex()
  32 {
  33     static pthread_mutex_t * g_stackMutext = NULL;
  34     if (g_stackMutext == NULL)
  35     {
  36         g_stackMutext = (pthread_mutex_t *)OICMalloc(sizeof(pthread_mutex_t));
  37         NS_VERIFY_NOT_NULL(g_stackMutext, NULL);
  38         pthread_mutex_init(g_stackMutext, NULL);
  39     }
  40
  41     return & g_stackMutext;
  42 }
  43
  44 char ** NSGetConsumerId()
  45 {
  46     static char * g_consumerId = NULL;
  47     return & g_consumerId;
  48 }
  49
  50 void NSSetConsumerId(char * cId)
  51 {
  52     NS_VERIFY_NOT_NULL_V(cId);
  53     char ** consumerId = NSGetConsumerId();
  54     NSOICFree(*consumerId);
  55     *consumerId = (char *)OICMalloc(sizeof(char) * NS_DEVICE_ID_LENGTH);
  56     NS_VERIFY_NOT_NULL_V(*consumerId);
  57
  58     OICStrcpy(*consumerId, sizeof(char) * NS_DEVICE_ID_LENGTH, cId);
  59 }
  60
  61 char * NSMakeRequestUriWithConsumerId(const char * uri)
  62 {
  63     NS_VERIFY_NOT_NULL(uri, NULL);
  64
  65     char * consumerId = OICStrdup(*NSGetConsumerId());
  66     NS_VERIFY_NOT_NULL(consumerId, NULL);
  67
  68     size_t uriLen = strlen(uri) + 1;
  69     size_t qKeyLen = sizeof(NS_QUERY_CONSUMER_ID);
  70     size_t queryLen = NS_DEVICE_ID_LENGTH + uriLen + qKeyLen + 2;
  71
  72     char * retQuery = (char *)OICMalloc(sizeof(char) * queryLen);
  73     NS_VERIFY_NOT_NULL(retQuery, NULL);
  74
  75     size_t index = 0;
  76     OICStrcpy((retQuery + index), uriLen, uri);
  77     index += uriLen - 1;
  78     OICStrcpy((retQuery + index), 2, "?");
  79     index += 1;
  80     OICStrcpy((retQuery + index), qKeyLen, NS_QUERY_CONSUMER_ID);
  81     index += qKeyLen - 1;
  82     OICStrcpy((retQuery + index), 2, "=");
  83     index += 1;
  84     OICStrcpy((retQuery + index), NS_DEVICE_ID_LENGTH, consumerId);
  85
  86     NSOICFree(consumerId);
  87
  88     return retQuery;
  89 }
  90
  91 bool * NSGetBoneIsStartedConsumer()
  92 {
  93     static bool g_isStartedConsumer = false;
  94
  95     return & g_isStartedConsumer;
  96 }
  97
  98 void NSSetIsStartedConsumer(bool setValue)
  99 {
 100     * NSGetBoneIsStartedConsumer() = setValue;
 101 }
 102
 103 bool NSIsStartedConsumer()
 104 {
 105     return * NSGetBoneIsStartedConsumer();
 106 }
 107
 108 NSProviderDiscoveredCallback * NSGetBoneDiscoverCb()
 109 {
 110     static NSProviderDiscoveredCallback g_discoverCb = NULL;
 111
 112     return & g_discoverCb;
 113 }
 114
 115 void NSSetDiscoverProviderCb(NSProviderDiscoveredCallback cb)
 116 {
 117     * NSGetBoneDiscoverCb() = cb;
 118 }
 119
 120 NSProviderDiscoveredCallback NSGetDiscoverCb()
 121 {
 122     return * NSGetBoneDiscoverCb();
 123 }
 124
 125 void * NSDiscoveredProviderFunc(void * provider)
 126 {
 127     NSGetDiscoverCb()((NSProvider *) provider);
 128
 129     return NULL;
 130 }
 131
 132 void NSDiscoveredProvider(NSProvider * provider)
 133 {
 134     NS_VERIFY_NOT_NULL_V(provider);
 135
 136     NSConsumerThread * thread = NSThreadInit(NSDiscoveredProviderFunc, (void *) provider);
 137     NS_VERIFY_NOT_NULL_V(thread);
 138 }
 139
 140 NSProviderChangedCallback * NSGetProviderChangedCb()
 141 {
 142     static NSProviderChangedCallback g_changedCb = NULL;
 143
 144     return & g_changedCb;
 145 }
 146
 147 void NSSetProviderChangedCb(NSProviderChangedCallback cb)
 148 {
 149     *(NSGetProviderChangedCb()) = cb;
 150 }
 151
 152 void NSProviderChanged(NSProvider * provider, NSResponse response)
 153 {
 154     (*(NSGetProviderChangedCb()))(provider, response);
 155 }
 156
 157 NSSyncInfoReceivedCallback * NSGetBoneNotificationSyncCb()
 158 {
 159     static NSSyncInfoReceivedCallback g_syncCb = NULL;
 160
 161     return & g_syncCb;
 162 }
 163
 164 void NSSetNotificationSyncCb(NSSyncInfoReceivedCallback cb)
 165 {
 166     * NSGetBoneNotificationSyncCb() = cb;
 167 }
 168
 169 void * NSNotificationSyncFunc(void * obj)
 170 {
 171     (* NSGetBoneNotificationSyncCb())((NSSyncInfo *) obj);
 172     return NULL;
 173 }
 174
 175 void NSNotificationSync(NSSyncInfo * sync)
 176 {
 177     NS_VERIFY_NOT_NULL_V(sync);
 178
 179     NSSyncInfo * retSync = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
 180     NS_VERIFY_NOT_NULL_V(retSync);
 181     memcpy(retSync, sync, sizeof(NSSyncInfo));
 182
 183     NSConsumerThread * thread = NSThreadInit(NSNotificationSyncFunc, (void *) retSync);
 184     NS_VERIFY_NOT_NULL_V(thread);
 185 }
 186
 187 NSMessageReceivedCallback  * NSGetBoneMessagePostedCb()
 188 {
 189     static NSMessageReceivedCallback  g_postCb = NULL;
 190
 191     return & g_postCb;
 192 }
 193
 194 void NSSetMessagePostedCb(NSMessageReceivedCallback  cb)
 195 {
 196     * NSGetBoneMessagePostedCb() = cb;
 197 }
 198
 199 NSMessageReceivedCallback  NSGetMessagePostedCb()
 200 {
 201     return * NSGetBoneMessagePostedCb();
 202 }
 203
 204 void * NSMessagePostFunc(void * obj)
 205 {
 206     NSGetMessagePostedCb()((NSMessage *) obj);
 207     return NULL;
 208 }
 209
 210 void NSMessagePost(NSMessage * msg)
 211 {
 212     NS_VERIFY_NOT_NULL_V(msg);
 213
 214     NSMessage * retMsg = NSCopyMessage(msg);
 215     NS_VERIFY_NOT_NULL_V(retMsg);
 216
 217     NSConsumerThread * thread = NSThreadInit(NSMessagePostFunc, (void *) retMsg);
 218     NS_VERIFY_NOT_NULL_V(thread);
 219 }
 220
 221 NSTask * NSMakeTask(NSTaskType type, void * data)
 222 {
 223     NSTask * retTask = OICMalloc(sizeof(NSTask));
 224     NS_VERIFY_NOT_NULL(retTask, NULL);
 225
 226     retTask->taskType = type;
 227     retTask->taskData = data;
 228     retTask->nextTask = NULL;
 229
 230     return retTask;
 231 }
 232
 233 NSMessage * NSCopyMessage(NSMessage * msg)
 234 {
 235     NS_VERIFY_NOT_NULL(msg, NULL);
 236
 237     NSMessage * newMsg = (NSMessage *)OICMalloc(sizeof(NSMessage));
 238     NS_VERIFY_NOT_NULL(newMsg, NULL);
 239
 240     OICStrcpy(newMsg->providerId, NS_DEVICE_ID_LENGTH, msg->providerId);
 241
 242     newMsg->messageId = msg->messageId;
 243     newMsg->title = OICStrdup(msg->title);
 244     newMsg->contentText = OICStrdup(msg->contentText);
 245     newMsg->sourceName = OICStrdup(msg->sourceName);
 246     newMsg->dateTime = OICStrdup(msg->dateTime);
 247     newMsg->type = msg->type;
 248     newMsg->topic = NULL;
 249     if (msg->topic && strlen(msg->topic) > 0)
 250     {
 251         newMsg->topic = OICStrdup(msg->topic);
 252     }
 253
 254     // TODO change to copy function.
 255     newMsg->mediaContents = msg->mediaContents;
 256
 257     return newMsg;
 258 }
 259 void NSRemoveMessage(NSMessage * msg)
 260 {
 261     NS_VERIFY_NOT_NULL_V(msg);
 262
 263     msg->messageId = 0;
 264     NSOICFree(msg->title);
 265     NSOICFree(msg->contentText);
 266     NSOICFree(msg->sourceName);
 267     NSOICFree(msg->dateTime);
 268     NSOICFree(msg->topic);
 269
 270     // TODO change to remove function.
 271     NSOICFree(msg->mediaContents);
 272
 273     NSOICFree(msg);
 274 }
 275
 276 void NSRemoveConnections(NSProviderConnectionInfo * connections)
 277 {
 278     NS_VERIFY_NOT_NULL_V(connections);
 279
 280     NSProviderConnectionInfo * tmp = connections;
 281
 282     while(tmp)
 283     {
 284         tmp->messageHandle = NULL;
 285         tmp->syncHandle = NULL;
 286         NSOICFree(tmp->addr);
 287         tmp = tmp->next;
 288     }
 289
 290     NSOICFree(connections);
 291 }
 292
 293 NSProviderConnectionInfo * NSCreateProviderConnections(OCDevAddr * inAddr)
 294 {
 295     NSProviderConnectionInfo * connections
 296         = (NSProviderConnectionInfo *)OICMalloc(sizeof(NSProviderConnectionInfo));
 297     NS_VERIFY_NOT_NULL(connections, NULL);
 298
 299     connections->addr = NULL;
 300     connections->messageHandle = NULL;
 301     connections->syncHandle = NULL;
 302     connections->isCloudConnection = false;
 303     connections->isSubscribing = false;
 304     connections->next = NULL;
 305
 306     if (inAddr)
 307     {
 308         connections->addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
 309         NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(connections->addr, NULL, NSRemoveConnections(connections));
 310         memcpy(connections->addr, inAddr, sizeof(OCDevAddr));
 311     }
 312
 313     return connections;
 314 }
 315
 316 NSProviderConnectionInfo * NSCopyProviderConnections(NSProviderConnectionInfo * conn)
 317 {
 318     NS_VERIFY_NOT_NULL(conn, NULL);
 319     NSProviderConnectionInfo * tmp = conn;
 320
 321     NSProviderConnectionInfo * retInfo = NSCreateProviderConnections(tmp->addr);
 322     NS_VERIFY_NOT_NULL(retInfo, NULL);
 323     tmp = tmp->next;
 324     NSProviderConnectionInfo * copyInfo = retInfo;
 325
 326     while(tmp)
 327     {
 328         copyInfo = NSCreateProviderConnections(tmp->addr);
 329         NS_VERIFY_NOT_NULL(copyInfo, NULL);
 330
 331         copyInfo->messageHandle = tmp->messageHandle;
 332         copyInfo->syncHandle = tmp->syncHandle;
 333         copyInfo->isCloudConnection = tmp->isCloudConnection;
 334         copyInfo->isSubscribing = tmp->isSubscribing;
 335         tmp = tmp->next;
 336         copyInfo = copyInfo->next;
 337     }
 338
 339     return retInfo;
 340 }
 341
 342 void NSRemoveTopicNode(NSTopicLL * topicNode)
 343 {
 344     NS_VERIFY_NOT_NULL_V(topicNode);
 345
 346     NSOICFree(topicNode->topicName);
 347     topicNode->next = NULL;
 348
 349     NSOICFree(topicNode);
 350 }
 351
 352 NSTopicLL * NSCopyTopicNode(NSTopicLL * topicNode)
 353 {
 354     NS_VERIFY_NOT_NULL(topicNode, NULL);
 355
 356     NSTopicLL * newTopicNode = (NSTopicLL *)OICMalloc(sizeof(NSTopicLL));
 357     NS_VERIFY_NOT_NULL(newTopicNode, NULL);
 358
 359     newTopicNode->topicName = OICStrdup(topicNode->topicName);
 360     newTopicNode->state = topicNode->state;
 361     newTopicNode->next = NULL;
 362
 363     return newTopicNode;
 364 }
 365
 366 NSResult NSInsertTopicNode(NSTopicLL * topicHead, NSTopicLL * topicNode)
 367 {
 368     NS_VERIFY_NOT_NULL(topicHead, NS_ERROR);
 369     NS_VERIFY_NOT_NULL(topicNode, NS_ERROR);
 370
 371     NSTopicLL * iter = topicHead;
 372     NSTopicLL * prev = NULL;
 373
 374     while (iter)
 375     {
 376         prev = iter;
 377         iter = (NSTopicLL *) iter->next;
 378     }
 379
 380     prev->next = topicNode;
 381     topicNode->next = NULL;
 382
 383     return NS_OK;
 384 }
 385
 386 void NSRemoveTopicLL(NSTopicLL * topicHead)
 387 {
 388     NS_VERIFY_NOT_NULL_V(topicHead);
 389
 390     NSTopicLL * iter = topicHead;
 391     NSTopicLL * following = NULL;
 392
 393     while (iter)
 394     {
 395         following = (NSTopicLL *) iter->next;
 396
 397         NSRemoveTopicNode(iter);
 398
 399         iter = following;
 400     }
 401 }
 402
 403 NSTopicLL * NSCopyTopicLL(NSTopicLL * topicHead)
 404 {
 405     NS_VERIFY_NOT_NULL(topicHead, NULL);
 406
 407     NSTopicLL * iter = topicHead;
 408
 409     NSTopicLL * newTopicHead = NSCopyTopicNode(iter);
 410     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicHead, NULL, NSRemoveTopicLL(newTopicHead));
 411
 412     iter = (NSTopicLL *) iter->next;
 413
 414     while (iter)
 415     {
 416         NSTopicLL * newTopicNode = NSCopyTopicNode(iter);
 417         NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicNode, NULL, NSRemoveTopicLL(newTopicHead));
 418
 419         NSResult ret = NSInsertTopicNode(newTopicHead, newTopicNode);
 420         NS_VERIFY_STACK_SUCCESS_WITH_POST_CLEANING(ret, NULL, NSRemoveTopicLL(newTopicHead));
 421
 422         iter = (NSTopicLL *) iter->next;
 423     }
 424
 425     return newTopicHead;
 426 }
 427
 428 void NSCopyProviderPostClean(
 429         NSProviderConnectionInfo * connections, NSProvider_internal * provider)
 430 {
 431     NSRemoveConnections(connections);
 432     NSOICFree(provider);
 433 }
 434
 435 NSProvider_internal * NSCopyProvider_internal(NSProvider_internal * prov)
 436 {
 437     NS_VERIFY_NOT_NULL(prov, NULL);
 438
 439     NSProviderConnectionInfo * connections = NSCopyProviderConnections(prov->connection);
 440     NS_VERIFY_NOT_NULL(connections, NULL);
 441
 442     NSProvider_internal * newProv = (NSProvider_internal *) OICMalloc(sizeof(NSProvider_internal));
 443     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProv, NULL, NSRemoveConnections(connections));
 444
 445     newProv->topicLL = NULL;
 446
 447     if (prov->topicLL)
 448     {
 449         NSTopicLL * newTopicLL = NSCopyTopicLL(prov->topicLL);
 450         NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newTopicLL, NULL,
 451                     NSCopyProviderPostClean(connections, newProv));
 452
 453         newProv->topicLL = newTopicLL;
 454     }
 455
 456     newProv->connection = connections;
 457     OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
 458     newProv->messageUri = OICStrdup(prov->messageUri);
 459     newProv->syncUri = OICStrdup(prov->syncUri);
 460     newProv->topicUri = OICStrdup(prov->topicUri);
 461     newProv->accessPolicy = prov->accessPolicy;
 462
 463     return newProv;
 464 }
 465
 466 NSProvider * NSCopyProvider(NSProvider_internal * prov)
 467 {
 468     NS_VERIFY_NOT_NULL(prov, NULL);
 469
 470     NSProvider * newProv = (NSProvider *) OICMalloc(sizeof(NSProvider));
 471     NS_VERIFY_NOT_NULL(newProv, NULL);
 472
 473     newProv->topicLL = NULL;
 474
 475     if (prov->topicLL)
 476     {
 477         NSTopicLL * topicList = NSCopyTopicLL(prov->topicLL);
 478         NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(topicList, NULL, NSRemoveProvider(newProv));
 479
 480         newProv->topicLL = topicList;
 481     }
 482
 483     OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
 484
 485     return newProv;
 486 }
 487
 488 void NSRemoveProvider_internal(NSProvider_internal * prov)
 489 {
 490     NS_VERIFY_NOT_NULL_V(prov);
 491
 492     NSOICFree(prov->messageUri);
 493     NSOICFree(prov->syncUri);
 494     NSOICFree(prov->topicUri);
 495     NSRemoveConnections(prov->connection);
 496     if (prov->topicLL)
 497     {
 498         NSRemoveTopicLL(prov->topicLL);
 499     }
 500
 501     NSOICFree(prov);
 502 }
 503
 504 void NSRemoveProvider(NSProvider * prov)
 505 {
 506     NS_VERIFY_NOT_NULL_V(prov);
 507
 508     if (prov->topicLL)
 509     {
 510         NSRemoveTopicLL(prov->topicLL);
 511     }
 512
 513     NSOICFree(prov);
 514 }
 515
 516 NSSyncInfo_internal * NSCopySyncInfo(NSSyncInfo_internal * syncInfo)
 517 {
 518     NS_VERIFY_NOT_NULL(syncInfo, NULL);
 519
 520     NSProviderConnectionInfo * connections = NSCopyProviderConnections(syncInfo->connection);
 521     NS_VERIFY_NOT_NULL(connections, NULL);
 522
 523     NSSyncInfo_internal * newSyncInfo = (NSSyncInfo_internal *)OICMalloc(sizeof(NSSyncInfo_internal));
 524     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newSyncInfo, NULL, NSRemoveConnections(connections));
 525
 526     OICStrcpy(newSyncInfo->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, syncInfo->providerId);
 527     newSyncInfo->messageId = syncInfo->messageId;
 528     newSyncInfo->state = syncInfo->state;
 529     newSyncInfo->connection = connections;
 530
 531     return newSyncInfo;
 532 }
 533
 534 void NSRemoveSyncInfo(NSSyncInfo_internal * syncInfo)
 535 {
 536     NS_VERIFY_NOT_NULL_V(syncInfo);
 537
 538     NSRemoveConnections(syncInfo->connection);
 539
 540     NSOICFree(syncInfo);
 541 }
 542
 543 OCStackResult NSInvokeRequest(OCDoHandle * handle,
 544         OCMethod method, const OCDevAddr * addr,
 545         const char * queryUrl, OCPayload * payload,
 546         void * callbackFunc, void * callbackData, OCConnectivityType type)
 547 {
 548     int mutexRet = pthread_mutex_lock(*(NSGetStackMutex()));
 549     NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
 550
 551     OCCallbackData cbdata = { 0, };
 552
 553     cbdata.cb = callbackFunc;
 554     cbdata.context = callbackData;
 555     cbdata.cd = NULL;
 556
 557     OCStackResult ret = OCDoResource(handle, method, queryUrl, addr,
 558                                      payload, type, NS_QOS, &cbdata, NULL, 0);
 559
 560     mutexRet = pthread_mutex_unlock(*(NSGetStackMutex()));
 561     NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
 562
 563     return ret;
 564 }
 565
 566 bool NSOCResultToSuccess(OCStackResult ret)
 567 {
 568     switch (ret)
 569     {
 570         case OC_STACK_OK:
 571         case OC_STACK_RESOURCE_CREATED:
 572         case OC_STACK_RESOURCE_DELETED:
 573         case OC_STACK_CONTINUE:
 574         case OC_STACK_RESOURCE_CHANGED:
 575             return true;
 576         default:
 577             NS_LOG_V(DEBUG, "OCStackResult : %d", (int)ret);
 578             return false;
 579     }
 580 }