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     NSProvider * retProvider = (NSProvider *)NSCopyProvider((NSProvider_internal *)provider);
 137     NS_VERIFY_NOT_NULL_V(retProvider);
 138
 139     NSConsumerThread * thread = NSThreadInit(NSDiscoveredProviderFunc, (void *) retProvider);
 140     NS_VERIFY_NOT_NULL_V(thread);
 141 }
 142
 143 NSSubscriptionAcceptedCallback * NSGetSubscriptionAcceptedCb()
 144 {
 145     static NSSubscriptionAcceptedCallback g_acceptCb = NULL;
 146
 147     return & g_acceptCb;
 148 }
 149
 150 void NSSetSubscriptionAcceptedCb(NSSubscriptionAcceptedCallback cb)
 151 {
 152     *(NSGetSubscriptionAcceptedCb()) = cb;
 153 }
 154
 155 void NSSubscriptionAccepted(NSProvider * provider)
 156 {
 157     (*(NSGetSubscriptionAcceptedCb()))(provider);
 158 }
 159
 160 NSSyncInfoReceivedCallback * NSGetBoneNotificationSyncCb()
 161 {
 162     static NSSyncInfoReceivedCallback g_syncCb = NULL;
 163
 164     return & g_syncCb;
 165 }
 166
 167 void NSSetNotificationSyncCb(NSSyncInfoReceivedCallback cb)
 168 {
 169     * NSGetBoneNotificationSyncCb() = cb;
 170 }
 171
 172 void * NSNotificationSyncFunc(void * obj)
 173 {
 174     (* NSGetBoneNotificationSyncCb())((NSSyncInfo *) obj);
 175     return NULL;
 176 }
 177
 178 void NSNotificationSync(NSSyncInfo * sync)
 179 {
 180     NS_VERIFY_NOT_NULL_V(sync);
 181
 182     NSSyncInfo * retSync = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
 183     NS_VERIFY_NOT_NULL_V(retSync);
 184     memcpy(retSync, sync, sizeof(NSSyncInfo));
 185
 186     NSConsumerThread * thread = NSThreadInit(NSNotificationSyncFunc, (void *) retSync);
 187     NS_VERIFY_NOT_NULL_V(thread);
 188 }
 189
 190 NSMessageReceivedCallback  * NSGetBoneMessagePostedCb()
 191 {
 192     static NSMessageReceivedCallback  g_postCb = NULL;
 193
 194     return & g_postCb;
 195 }
 196
 197 void NSSetMessagePostedCb(NSMessageReceivedCallback  cb)
 198 {
 199     * NSGetBoneMessagePostedCb() = cb;
 200 }
 201
 202 NSMessageReceivedCallback  NSGetMessagePostedCb()
 203 {
 204     return * NSGetBoneMessagePostedCb();
 205 }
 206
 207 void * NSMessagePostFunc(void * obj)
 208 {
 209     NSGetMessagePostedCb()((NSMessage *) obj);
 210     return NULL;
 211 }
 212
 213 void NSMessagePost(NSMessage * msg)
 214 {
 215     NS_VERIFY_NOT_NULL_V(msg);
 216
 217     NSMessage * retMsg = (NSMessage *)NSCopyMessage((NSMessage_consumer *)msg);
 218     NS_VERIFY_NOT_NULL_V(retMsg);
 219
 220     NSConsumerThread * thread = NSThreadInit(NSMessagePostFunc, (void *) retMsg);
 221     NS_VERIFY_NOT_NULL_V(thread);
 222 }
 223
 224 NSTask * NSMakeTask(NSTaskType type, void * data)
 225 {
 226     NSTask * retTask = OICMalloc(sizeof(NSTask));
 227     NS_VERIFY_NOT_NULL(retTask, NULL);
 228
 229     retTask->taskType = type;
 230     retTask->taskData = data;
 231     retTask->nextTask = NULL;
 232
 233     return retTask;
 234 }
 235
 236 NSMessage_consumer * NSCopyMessage(NSMessage_consumer * msg)
 237 {
 238     NS_VERIFY_NOT_NULL(msg, NULL);
 239
 240     NSMessage_consumer * newMsg = (NSMessage_consumer *)OICMalloc(sizeof(NSMessage_consumer));
 241     NS_VERIFY_NOT_NULL(newMsg, NULL);
 242
 243     OICStrcpy(newMsg->providerId, NS_DEVICE_ID_LENGTH, msg->providerId);
 244     newMsg->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
 245     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newMsg, NULL, NSOICFree(newMsg));
 246     memcpy(newMsg->i_addr, msg->i_addr, sizeof(OCDevAddr));
 247
 248     newMsg->messageId = msg->messageId;
 249     newMsg->title = OICStrdup(msg->title);
 250     newMsg->contentText = OICStrdup(msg->contentText);
 251     newMsg->sourceName = OICStrdup(msg->sourceName);
 252     newMsg->type = msg->type;
 253
 254     return newMsg;
 255 }
 256 void NSRemoveMessage(NSMessage_consumer * msg)
 257 {
 258     NS_VERIFY_NOT_NULL_V(msg);
 259
 260     msg->messageId = 0;
 261     NSOICFree(msg->title);
 262     NSOICFree(msg->contentText);
 263     NSOICFree(msg->sourceName);
 264     NSOICFree(msg->i_addr);
 265
 266     NSOICFree(msg);
 267 }
 268
 269 void NSRemoveConnections(NSProviderConnectionInfo * connections)
 270 {
 271     NS_VERIFY_NOT_NULL_V(connections);
 272
 273     NSProviderConnectionInfo * tmp = connections;
 274
 275     while(tmp)
 276     {
 277         tmp->messageHandle = NULL;
 278         tmp->syncHandle = NULL;
 279         NSOICFree(tmp->addr);
 280         tmp = tmp->next;
 281     }
 282
 283     NSOICFree(connections);
 284 }
 285
 286 NSProviderConnectionInfo * NSCreateProviderConnections(OCDevAddr * inAddr)
 287 {
 288     NSProviderConnectionInfo * connections
 289         = (NSProviderConnectionInfo *)OICMalloc(sizeof(NSProviderConnectionInfo));
 290     NS_VERIFY_NOT_NULL(connections, NULL);
 291
 292     connections->addr = NULL;
 293     connections->messageHandle = NULL;
 294     connections->syncHandle = NULL;
 295     connections->isCloudConnection = false;
 296     connections->isSubscribing = false;
 297     connections->next = NULL;
 298
 299     if (inAddr)
 300     {
 301         connections->addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
 302         NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(connections->addr, NULL, NSRemoveConnections(connections));
 303         memcpy(connections->addr, inAddr, sizeof(OCDevAddr));
 304     }
 305
 306     return connections;
 307 }
 308
 309 NSProviderConnectionInfo * NSCopyProviderConnections(NSProviderConnectionInfo * conn)
 310 {
 311     NS_VERIFY_NOT_NULL(conn, NULL);
 312     NSProviderConnectionInfo * tmp = conn;
 313
 314     NSProviderConnectionInfo * retInfo = NSCreateProviderConnections(tmp->addr);
 315     tmp = tmp->next;
 316     NSProviderConnectionInfo * copyInfo = retInfo;
 317
 318     while(tmp)
 319     {
 320         copyInfo = NSCreateProviderConnections(tmp->addr);
 321         NS_VERIFY_NOT_NULL(copyInfo, NULL);
 322
 323         copyInfo->messageHandle = tmp->messageHandle;
 324         copyInfo->syncHandle = tmp->syncHandle;
 325         copyInfo->isCloudConnection = tmp->isCloudConnection;
 326         copyInfo->isSubscribing = tmp->isSubscribing;
 327         tmp = tmp->next;
 328         copyInfo = copyInfo->next;
 329     }
 330
 331     return retInfo;
 332 }
 333
 334 NSProvider_internal * NSCopyProvider(NSProvider_internal * prov)
 335 {
 336     NS_VERIFY_NOT_NULL(prov, NULL);
 337
 338     NSProviderConnectionInfo * connections = NSCopyProviderConnections(prov->connection);
 339     NS_VERIFY_NOT_NULL(connections, NULL);
 340
 341     NSProvider_internal * newProv = (NSProvider_internal *)OICMalloc(sizeof(NSProvider_internal));
 342     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProv, NULL, NSRemoveConnections(connections));
 343
 344     newProv->connection = connections;
 345     OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
 346     newProv->messageUri = OICStrdup(prov->messageUri);
 347     newProv->syncUri = OICStrdup(prov->syncUri);
 348     newProv->accessPolicy = prov->accessPolicy;
 349
 350     return newProv;
 351 }
 352 void NSRemoveProvider(NSProvider_internal * prov)
 353 {
 354     NS_VERIFY_NOT_NULL_V(prov);
 355
 356     NSOICFree(prov->messageUri);
 357     NSOICFree(prov->syncUri);
 358     NSRemoveConnections(prov->connection);
 359
 360     NSOICFree(prov);
 361 }
 362
 363 OCStackResult NSInvokeRequest(OCDoHandle * handle,
 364         OCMethod method, const OCDevAddr * addr,
 365         const char * queryUrl, OCPayload * payload,
 366         void * callbackFunc, void * callbackData, OCConnectivityType type)
 367 {
 368     int mutexRet = pthread_mutex_lock(*(NSGetStackMutex()));
 369     NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
 370
 371     OCCallbackData cbdata = { 0, };
 372
 373     cbdata.cb = callbackFunc;
 374     cbdata.context = callbackData;
 375     cbdata.cd = NULL;
 376
 377     OCStackResult ret = OCDoResource(handle, method, queryUrl, addr,
 378                                      payload, type, NS_QOS, &cbdata, NULL, 0);
 379
 380     mutexRet = pthread_mutex_unlock(*(NSGetStackMutex()));
 381     NS_VERIFY_NOT_NULL(mutexRet != 0 ? NULL : (void *)1, OC_STACK_ERROR);
 382
 383     return ret;
 384 }
 385
 386 bool NSOCResultToSuccess(OCStackResult ret)
 387 {
 388     switch (ret)
 389     {
 390         case OC_STACK_OK:
 391         case OC_STACK_RESOURCE_CREATED:
 392         case OC_STACK_RESOURCE_DELETED:
 393         case OC_STACK_CONTINUE:
 394         case OC_STACK_RESOURCE_CHANGED:
 395             return true;
 396         default:
 397             return false;
 398     }
 399 }