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 #define NS_QUERY_CONSUMER_ID "consumerid"
  28
  29 char ** NSGetConsumerId()
  30 {
  31     static char * g_consumerId = NULL;
  32     return & g_consumerId;
  33 }
  34
  35 void NSSetConsumerId(char * cId)
  36 {
  37     NS_VERIFY_NOT_NULL_V(cId);
  38     char ** consumerId = NSGetConsumerId();
  39     NSOICFree(*consumerId);
  40     *consumerId = (char *)OICMalloc(sizeof(char) * NS_DEVICE_ID_LENGTH);
  41     NS_VERIFY_NOT_NULL_V(*consumerId);
  42
  43     OICStrcpy(*consumerId, sizeof(char) * NS_DEVICE_ID_LENGTH, cId);
  44 }
  45
  46 char * NSMakeRequestUriWithConsumerId(const char * uri)
  47 {
  48     NS_VERIFY_NOT_NULL(uri, NULL);
  49
  50     char * consumerId = OICStrdup(*NSGetConsumerId());
  51     NS_VERIFY_NOT_NULL(consumerId, NULL);
  52
  53     size_t uriLen = strlen(uri) + 1;
  54     size_t qKeyLen = sizeof(NS_QUERY_CONSUMER_ID);
  55     size_t queryLen = NS_DEVICE_ID_LENGTH + uriLen + qKeyLen + 2;
  56
  57     char * retQuery = (char *)OICMalloc(sizeof(char) * queryLen);
  58     NS_VERIFY_NOT_NULL(retQuery, NULL);
  59
  60     size_t index = 0;
  61     OICStrcpy((retQuery + index), uriLen, uri);
  62     index += uriLen - 1;
  63     OICStrcpy((retQuery + index), 2, "?");
  64     index += 1;
  65     OICStrcpy((retQuery + index), qKeyLen, NS_QUERY_CONSUMER_ID);
  66     index += qKeyLen - 1;
  67     OICStrcpy((retQuery + index), 2, "=");
  68     index += 1;
  69     OICStrcpy((retQuery + index), NS_DEVICE_ID_LENGTH, consumerId);
  70
  71     NSOICFree(consumerId);
  72
  73     return retQuery;
  74 }
  75
  76 bool * NSGetBoneIsStartedConsumer()
  77 {
  78     static bool g_isStartedConsumer = false;
  79
  80     return & g_isStartedConsumer;
  81 }
  82
  83 void NSSetIsStartedConsumer(bool setValue)
  84 {
  85     * NSGetBoneIsStartedConsumer() = setValue;
  86 }
  87
  88 bool NSIsStartedConsumer()
  89 {
  90     return * NSGetBoneIsStartedConsumer();
  91 }
  92
  93 NSProviderDiscoveredCallback * NSGetBoneDiscoverCb()
  94 {
  95     static NSProviderDiscoveredCallback g_discoverCb = NULL;
  96
  97     return & g_discoverCb;
  98 }
  99
 100 void NSSetDiscoverProviderCb(NSProviderDiscoveredCallback cb)
 101 {
 102     * NSGetBoneDiscoverCb() = cb;
 103 }
 104
 105 NSProviderDiscoveredCallback NSGetDiscoverCb()
 106 {
 107     return * NSGetBoneDiscoverCb();
 108 }
 109
 110 void * NSDiscoveredProviderFunc(void * provider)
 111 {
 112     NSGetDiscoverCb()((NSProvider *) provider);
 113
 114     return NULL;
 115 }
 116
 117 void NSDiscoveredProvider(NSProvider * provider)
 118 {
 119     NSConsumerThread * thread = NSThreadInit(NSDiscoveredProviderFunc, (void *) provider);
 120     NS_VERIFY_NOT_NULL_V(thread);
 121 }
 122
 123 NSSubscriptionAcceptedCallback * NSGetSubscriptionAcceptedCb()
 124 {
 125     static NSSubscriptionAcceptedCallback g_acceptCb = NULL;
 126
 127     return & g_acceptCb;
 128 }
 129
 130 void NSSetSubscriptionAcceptedCb(NSSubscriptionAcceptedCallback cb)
 131 {
 132     *(NSGetSubscriptionAcceptedCb()) = cb;
 133 }
 134
 135 void NSSubscriptionAccepted(NSProvider * provider)
 136 {
 137     (*(NSGetSubscriptionAcceptedCb()))(provider);
 138 }
 139
 140 NSSyncInfoReceivedCallback * NSGetBoneNotificationSyncCb()
 141 {
 142     static NSSyncInfoReceivedCallback g_syncCb = NULL;
 143
 144     return & g_syncCb;
 145 }
 146
 147 void NSSetNotificationSyncCb(NSSyncInfoReceivedCallback cb)
 148 {
 149     * NSGetBoneNotificationSyncCb() = cb;
 150 }
 151
 152 void * NSNotificationSyncFunc(void * obj)
 153 {
 154     (* NSGetBoneNotificationSyncCb())((NSSyncInfo *) obj);
 155     return NULL;
 156 }
 157
 158 void NSNotificationSync(NSSyncInfo * sync)
 159 {
 160     NS_VERIFY_NOT_NULL_V(sync);
 161     NSConsumerThread * thread = NSThreadInit(NSNotificationSyncFunc, (void *) sync);
 162     NS_VERIFY_NOT_NULL_V(thread);
 163 }
 164
 165 NSMessageReceivedCallback  * NSGetBoneMessagePostedCb()
 166 {
 167     static NSMessageReceivedCallback  g_postCb = NULL;
 168
 169     return & g_postCb;
 170 }
 171
 172 void NSSetMessagePostedCb(NSMessageReceivedCallback  cb)
 173 {
 174     * NSGetBoneMessagePostedCb() = cb;
 175 }
 176
 177 NSMessageReceivedCallback  NSGetMessagePostedCb()
 178 {
 179     return * NSGetBoneMessagePostedCb();
 180 }
 181
 182 void * NSMessagePostFunc(void * obj)
 183 {
 184     NSGetMessagePostedCb()((NSMessage *) obj);
 185     return NULL;
 186 }
 187
 188 void NSMessagePost(NSMessage * msg)
 189 {
 190     NS_VERIFY_NOT_NULL_V(msg);
 191     NSConsumerThread * thread = NSThreadInit(NSMessagePostFunc, (void *) msg);
 192     NS_VERIFY_NOT_NULL_V(thread);
 193 }
 194
 195 NSTask * NSMakeTask(NSTaskType type, void * data)
 196 {
 197     NSTask * retTask = OICMalloc(sizeof(NSTask));
 198     NS_VERIFY_NOT_NULL(retTask, NULL);
 199
 200     retTask->taskType = type;
 201     retTask->taskData = data;
 202     retTask->nextTask = NULL;
 203
 204     return retTask;
 205 }
 206
 207 NSMessage_consumer * NSCopyMessage(NSMessage_consumer * msg)
 208 {
 209     NS_VERIFY_NOT_NULL(msg, NULL);
 210
 211     NSMessage_consumer * newMsg = (NSMessage_consumer *)OICMalloc(sizeof(NSMessage_consumer));
 212     NS_VERIFY_NOT_NULL(newMsg, NULL);
 213
 214     OICStrcpy(newMsg->providerId, NS_DEVICE_ID_LENGTH, msg->providerId);
 215     newMsg->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
 216     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newMsg, NULL, OICFree(newMsg));
 217     memcpy(newMsg->i_addr, msg->i_addr, sizeof(OCDevAddr));
 218
 219     newMsg->messageId = msg->messageId;
 220     newMsg->title = OICStrdup(msg->title);
 221     newMsg->contentText = OICStrdup(msg->contentText);
 222     newMsg->sourceName = OICStrdup(msg->sourceName);
 223
 224     return newMsg;
 225 }
 226 void NSRemoveMessage(NSMessage_consumer * msg)
 227 {
 228     msg->messageId = 0;
 229     NSOICFree(msg->title);
 230     NSOICFree(msg->contentText);
 231     NSOICFree(msg->sourceName);
 232     NSOICFree(msg->i_addr);
 233
 234     NSOICFree(msg);
 235 }
 236
 237 NSProvider_internal * NSCopyProvider(NSProvider_internal * prov)
 238 {
 239     NS_VERIFY_NOT_NULL(prov, NULL);
 240
 241     NSProvider_internal * newProv = (NSProvider_internal *)OICMalloc(sizeof(NSProvider_internal));
 242     NS_VERIFY_NOT_NULL(newProv, NULL);
 243
 244     OICStrcpy(newProv->providerId, NS_DEVICE_ID_LENGTH, prov->providerId);
 245     newProv->i_addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
 246     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProv, NULL, OICFree(newProv));
 247     memcpy(newProv->i_addr, prov->i_addr, sizeof(OCDevAddr));
 248
 249     newProv->messageUri = OICStrdup(prov->messageUri);
 250     newProv->syncUri = OICStrdup(prov->syncUri);
 251     newProv->i_messageHandle = prov->i_messageHandle;
 252     newProv->i_syncHandle = prov->i_syncHandle;
 253     newProv->accessPolicy = prov->accessPolicy;
 254
 255     return newProv;
 256 }
 257 void NSRemoveProvider(NSProvider_internal * prov)
 258 {
 259     NSOICFree(prov->messageUri);
 260     NSOICFree(prov->syncUri);
 261     NSOICFree(prov->i_messageHandle);
 262     NSOICFree(prov->i_syncHandle);
 263     NSOICFree(prov->i_addr);
 264
 265     NSOICFree(prov);
 266 }
 267
 268 OCStackResult NSInvokeRequest(OCDoHandle * handle,
 269         OCMethod method, const OCDevAddr * addr,
 270         const char * queryUrl, OCPayload * payload,
 271         void * callbackFunc, void * callbackData)
 272 {
 273     OCCallbackData cbdata;
 274
 275     cbdata.cb = callbackFunc;
 276     cbdata.context = callbackData;
 277     cbdata.cd = NULL;
 278
 279     return OCDoResource(handle, method, queryUrl, addr,
 280             payload, CT_DEFAULT, NS_QOS, &cbdata, NULL, 0);
 281 }