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