service/notification/src/consumer/NSConsumerCommunication.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 "NSConstants.h"
  22 #include "NSConsumerCommon.h"
  23 #include "NSConsumerCommunication.h"
  24 #include "oic_malloc.h"
  25 #include "oic_string.h"
  26 #include "ocpayload.h"
  27
  28 #define NS_SYNC_URI "/notification/sync"
  29
  30 unsigned long NS_MESSAGE_ACCEPTANCE = 1;
  31
  32 NSMessage_consumer * NSCreateMessage_internal(uint64_t msgId, const char * providerId);
  33 NSSyncInfo * NSCreateSyncInfo_consumer(uint64_t msgId, const char * providerId, NSSyncType state);
  34
  35 NSMessage_consumer * NSGetMessage(OCClientResponse * clientResponse);
  36 NSSyncInfo * NSGetSyncInfoc(OCClientResponse * clientResponse);
  37
  38 OCRepPayload * NSGetofSyncInfoPayload(NSMessage_consumer * message, int type);
  39 OCStackResult NSSendSyncInfo(NSMessage_consumer * message, int type);
  40
  41 // TODO it seem to not to be this file
  42 NSResult NSPushToCache(OCClientResponse * clientResponse, NSTaskType type);
  43
  44 NSResult NSConsumerSubscribeProvider(NSProvider * provider)
  45 {
  46     NSProvider_internal * provider_internal = (NSProvider_internal *) provider;
  47     NS_VERTIFY_NOT_NULL(provider_internal, NS_ERROR);
  48
  49     NS_LOG(DEBUG, "get subscribe message query");
  50     char * query = NSGetQuery(provider_internal->messageUri);
  51     NS_VERTIFY_NOT_NULL(query, NS_ERROR);
  52
  53     NS_LOG(DEBUG, "subscribe message");
  54     NS_LOG_V(DEBUG, "subscribe query : %s", query);
  55     OCStackResult ret = NSInvokeRequest(&(provider_internal->messageHandle),
  56                           OC_REST_OBSERVE, provider_internal->addr,
  57                           query, NULL, NSConsumerMessageListener, NULL);
  58     NS_VERTIFY_STACK_OK(ret, NS_ERROR);
  59     NSOICFree(query);
  60
  61     NS_LOG(DEBUG, "get subscribe sync query");
  62     query = NSGetQuery(provider_internal->syncUri);
  63     NS_VERTIFY_NOT_NULL(query, NS_ERROR);
  64
  65     NS_LOG(DEBUG, "subscribe sync");
  66     NS_LOG_V(DEBUG, "subscribe query : %s", query);
  67     ret = NSInvokeRequest(&(provider_internal->syncHandle),
  68                           OC_REST_OBSERVE, provider_internal->addr,
  69                           query, NULL, NSConsumerSyncInfoListener, NULL);
  70     NS_VERTIFY_STACK_OK(ret, NS_ERROR);
  71     NSOICFree(query);
  72
  73     return NS_OK;
  74 }
  75
  76 OCStackApplicationResult NSConsumerCheckPostResult(
  77         void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
  78 {
  79     (void) ctx;
  80     (void) handle;
  81
  82     NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
  83     NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
  84
  85     return OC_STACK_KEEP_TRANSACTION;
  86 }
  87
  88 void NSRemoveSyncInfoObj(NSSyncInfo * sync)
  89 {
  90     NSOICFree(sync);
  91 }
  92
  93 OCStackApplicationResult NSConsumerSyncInfoListener(
  94         void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
  95 {
  96     (void) ctx;
  97     (void) handle;
  98
  99     NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
 100     NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
 101
 102     NS_LOG(DEBUG, "get NSSyncInfo");
 103     NSSyncInfo * newSync = NSGetSyncInfoc(clientResponse);
 104     NS_VERTIFY_NOT_NULL(newSync, OC_STACK_KEEP_TRANSACTION);
 105
 106     NSTaskType taskType = TASK_RECV_SYNCINFO;
 107
 108     NS_LOG(DEBUG, "build NSTask");
 109     NSTask * task = NSMakeTask(taskType, (void *) newSync);
 110     NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(task,
 111                OC_STACK_KEEP_TRANSACTION, NSRemoveSyncInfoObj(newSync));
 112
 113     NSConsumerPushEvent(task);
 114
 115     return OC_STACK_KEEP_TRANSACTION;
 116 }
 117
 118 OCStackApplicationResult NSConsumerMessageListener(
 119         void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
 120 {
 121     (void) ctx;
 122     (void) handle;
 123
 124     NS_VERTIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
 125     NS_VERTIFY_STACK_OK(clientResponse->result, OC_STACK_KEEP_TRANSACTION);
 126
 127     NS_LOG(DEBUG, "build NSMessage");
 128     NSMessage_consumer * newNoti = NSGetMessage(clientResponse);
 129     NS_VERTIFY_NOT_NULL(newNoti, OC_STACK_KEEP_TRANSACTION);
 130
 131     NSTaskType type = TASK_CONSUMER_RECV_MESSAGE;
 132
 133     if (newNoti->messageId == NS_MESSAGE_ACCEPTANCE)
 134     {
 135         NS_LOG(DEBUG, "Receive Subscribe confirm");
 136         type = TASK_CONSUMER_RECV_SUBSCRIBE_CONFIRMED;
 137     }
 138     else
 139     {
 140         NS_LOG(DEBUG, "Receive new message");
 141     }
 142
 143     NS_LOG(DEBUG, "build NSTask");
 144     NSTask * task = NSMakeTask(type, (void *) newNoti);
 145     NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveMessage(newNoti));
 146
 147     NSConsumerPushEvent(task);
 148
 149     return OC_STACK_KEEP_TRANSACTION;
 150 }
 151
 152 NSResult NSPushToCache(OCClientResponse * clientResponse, NSTaskType type)
 153 {
 154     NSMessage_consumer * cachedNoti = NSGetMessage(clientResponse);
 155     NS_LOG(DEBUG, "build NSMessage");
 156     NS_VERTIFY_NOT_NULL(cachedNoti, NS_ERROR);
 157
 158     NS_LOG(DEBUG, "build NSTask");
 159     NSTask * task = NSMakeTask(type, (void *) cachedNoti);
 160     NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveMessage(cachedNoti));
 161
 162     NSConsumerPushEvent(task);
 163
 164     return NS_OK;
 165 }
 166
 167 void NSGetMessagePostClean(char * pId, OCDevAddr * addr)
 168 {
 169     NSOICFree(pId);
 170     NSOICFree(addr);
 171 }
 172
 173 NSMessage_consumer * NSGetMessage(OCClientResponse * clientResponse)
 174 {
 175     NS_VERTIFY_NOT_NULL(clientResponse->payload, NULL);
 176     OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
 177
 178     NS_LOG(DEBUG, "get msg id");
 179     uint64_t id = NULL;
 180     bool getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t *)&id);
 181     NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 182
 183     NS_LOG(DEBUG, "get provider id");
 184     char * pId = NULL;
 185     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, &pId);
 186     NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 187
 188     NS_LOG(DEBUG, "get provider address");
 189     OCDevAddr * addr = (OCDevAddr *)OICMalloc(sizeof(OCDevAddr));
 190     NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(addr, NULL, NSGetMessagePostClean(pId, addr));
 191     memcpy(addr, clientResponse->addr, sizeof(OCDevAddr));
 192
 193     NS_LOG(DEBUG, "create NSMessage");
 194     NSMessage_consumer * retNoti = NSCreateMessage_internal(id, pId);
 195     NS_VERTIFY_NOT_NULL_WITH_POST_CLEANING(retNoti, NULL, NSGetMessagePostClean(pId, addr));
 196     NSOICFree(pId);
 197
 198     retNoti->addr = addr;
 199     retNoti->messageTypes = Notification;
 200
 201     NS_LOG(DEBUG, "get msg optional field");
 202     OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TITLE, &retNoti->title);
 203     OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TEXT, &retNoti->contentText);
 204     OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_SOURCE, &retNoti->sourceName);
 205
 206     OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_TYPE, (int64_t *)&retNoti->type);
 207     OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_DATETIME, &retNoti->dateTime);
 208     OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_TTL, (int64_t *)&retNoti->ttl);
 209
 210     NS_LOG_V(DEBUG, "Msg Address : %s", retNoti->addr->addr);
 211     NS_LOG_V(DEBUG, "Msg ID      : %ld", retNoti->messageId);
 212     NS_LOG_V(DEBUG, "Msg Title   : %s", retNoti->title);
 213     NS_LOG_V(DEBUG, "Msg Content : %s", retNoti->contentText);
 214     NS_LOG_V(DEBUG, "Msg Source  : %s", retNoti->sourceName);
 215     NS_LOG_V(DEBUG, "Msg Type    : %d", retNoti->type);
 216     NS_LOG_V(DEBUG, "Msg Date    : %s", retNoti->dateTime);
 217     NS_LOG_V(DEBUG, "Msg ttl     : %ld", retNoti->ttl);
 218
 219     return retNoti;
 220 }
 221
 222 NSSyncInfo * NSGetSyncInfoc(OCClientResponse * clientResponse)
 223 {
 224     NS_VERTIFY_NOT_NULL(clientResponse->payload, NULL);
 225
 226     OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
 227
 228     NS_LOG(DEBUG, "get msg id");
 229     uint64_t id = NULL;
 230     bool getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t *)&id);
 231     NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 232
 233     NS_LOG(DEBUG, "get provider id");
 234     char * pId = NULL;
 235     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, &pId);
 236     NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 237
 238     NS_LOG(DEBUG, "get state");
 239     int64_t state = 0;
 240     getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_STATE, & state);
 241     NS_VERTIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 242
 243     NS_LOG(DEBUG, "create NSSyncInfo");
 244     NSSyncInfo * retSync = NSCreateSyncInfo_consumer(id, pId, (NSSyncType)state);
 245     NS_VERTIFY_NOT_NULL(retSync, NULL);
 246
 247     NS_LOG_V(DEBUG, "Sync ID : %ld", retSync->messageId);
 248     NS_LOG_V(DEBUG, "Sync State : %d", (int) retSync->state);
 249     NS_LOG_V(DEBUG, "Sync Provider ID : %s", retSync->providerId);
 250
 251     return retSync;
 252 }
 253
 254 NSMessage_consumer * NSCreateMessage_internal(uint64_t id, const char * providerId)
 255 {
 256     NSMessage_consumer * retNoti = (NSMessage_consumer *)OICMalloc(sizeof(NSMessage_consumer));
 257     NS_VERTIFY_NOT_NULL(retNoti, NULL);
 258
 259     retNoti->messageId = id;
 260     OICStrcpy(retNoti->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
 261     retNoti->title = NULL;
 262     retNoti->contentText = NULL;
 263     retNoti->sourceName = NULL;
 264     retNoti->type = NS_MESSAGE_INFO;
 265     retNoti->dateTime = NULL;
 266     retNoti->ttl = 0;
 267     retNoti->addr = NULL;
 268
 269     return retNoti;
 270 }
 271
 272 NSSyncInfo * NSCreateSyncInfo_consumer(uint64_t msgId, const char * providerId, NSSyncType state)
 273 {
 274     NSSyncInfo * retSync = (NSSyncInfo *)OICMalloc(sizeof(NSSyncInfo));
 275     NS_VERTIFY_NOT_NULL(retSync, NULL);
 276
 277     retSync->messageId = msgId;
 278     retSync->state = state;
 279     OICStrcpy(retSync->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
 280
 281     return retSync;
 282 }
 283
 284 void NSConsumerCommunicationTaskProcessing(NSTask * task)
 285 {
 286     NS_VERTIFY_NOT_NULL_V(task);
 287
 288     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
 289     if (task->taskType == TASK_CONSUMER_REQ_SUBSCRIBE)
 290     {
 291         NS_LOG(DEBUG, "Request Subscribe");
 292         NSResult ret = NSConsumerSubscribeProvider((NSProvider *)task->taskData);
 293         NS_VERTIFY_NOT_NULL_V(ret == NS_OK ? (void *)1 : NULL);
 294     }
 295     else if (task->taskType == TASK_SEND_READ || task->taskType == TASK_SEND_DISMISS)
 296     {
 297         NSMessage_consumer * message = (NSMessage_consumer *) task->taskData;
 298         NS_VERTIFY_NOT_NULL_V(message);
 299
 300         OCStackResult ret = NSSendSyncInfo(message, (task->taskType == TASK_SEND_READ) ? 0 : 1);
 301         NS_VERTIFY_STACK_OK_V(ret);
 302
 303     }
 304     else if (task->taskType == TASK_CONSUMER_REQ_SUBSCRIBE_CANCEL)
 305     {
 306         NSProvider_internal * provider = (NSProvider_internal *)task->taskData;
 307
 308         OCCancel(provider->messageHandle, NS_QOS, NULL, 0);
 309         OCCancel(provider->syncHandle, NS_QOS, NULL, 0);
 310     }
 311     else
 312     {
 313         NS_LOG(ERROR, "Unknown type message");
 314     }
 315 }
 316
 317 OCRepPayload * NSGetofSyncInfoPayload(NSMessage_consumer * message, int type)
 318 {
 319     OCRepPayload * payload = OCRepPayloadCreate();
 320     NS_VERTIFY_NOT_NULL(payload, NULL);
 321
 322     OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_MESSAGE_ID, (int64_t)message->messageId);
 323     OCRepPayloadSetPropInt(payload, NS_ATTRIBUTE_STATE, type);
 324
 325     return payload;
 326 }
 327
 328 OCStackResult NSSendSyncInfo(NSMessage_consumer * message, int type)
 329 {
 330     OCRepPayload * payload = NSGetofSyncInfoPayload(message, type);
 331     NS_VERTIFY_NOT_NULL(payload, OC_STACK_ERROR);
 332
 333     return NSInvokeRequest(NULL, OC_REST_POST, message->addr,
 334                            NS_SYNC_URI, (OCPayload*)payload,
 335                            NSConsumerCheckPostResult, NULL);
 336 }