service/notification/src/consumer/NSConsumerDiscovery.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 "NSConsumerDiscovery.h"
  22
  23 #include <string.h>
  24 #include "NSCommon.h"
  25 #include "NSConsumerCommon.h"
  26 #include "NSConstants.h"
  27 #include "ocpayload.h"
  28 #include "oic_malloc.h"
  29 #include "oic_string.h"
  30
  31 #define NS_DISCOVER_QUERY "/oic/res?rt=oic.r.notification"
  32 #define NS_PRESENCE_SUBSCRIBE_QUERY_TCP "/oic/ad?rt=oic.r.notification"
  33 #define NS_GET_INFORMATION_QUERY "/notification?if=oic.if.notification"
  34
  35 NSProvider_internal * NSGetProvider(OCClientResponse * clientResponse);
  36
  37 OCDevAddr * NSChangeAddress(const char * address);
  38
  39 OCStackApplicationResult NSConsumerPresenceListener(
  40         void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
  41 {
  42     (void) ctx;
  43     (void) handle;
  44
  45     NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
  46     NS_VERIFY_STACK_SUCCESS(
  47             NSOCResultToSuccess(clientResponse->result), OC_STACK_KEEP_TRANSACTION);
  48
  49     NS_LOG_V(DEBUG, "Presence income : %s:%d",
  50             clientResponse->devAddr.addr, clientResponse->devAddr.port);
  51     NS_LOG_V(DEBUG, "Presence result : %d",
  52             clientResponse->result);
  53     NS_LOG_V(DEBUG, "Presence sequenceNum : %d",
  54             clientResponse->sequenceNumber);
  55     NS_LOG_V(DEBUG, "Presence Transport Type : %d",
  56                 clientResponse->devAddr.adapter);
  57
  58     if (!NSIsStartedConsumer())
  59     {
  60         return OC_STACK_DELETE_TRANSACTION;
  61     }
  62
  63     OCPresencePayload * payload = (OCPresencePayload *)clientResponse->payload;
  64     if (payload->trigger == OC_PRESENCE_TRIGGER_DELETE ||
  65             clientResponse->result == OC_STACK_PRESENCE_STOPPED)
  66     {
  67         // TODO find request and cancel
  68         NS_LOG(DEBUG, "stopped presence or resource is deleted.");
  69         //OCCancel(handle, NS_QOS, NULL, 0);
  70     }
  71
  72     else if (payload->trigger == OC_PRESENCE_TRIGGER_CREATE)
  73     {
  74         NS_LOG(DEBUG, "started presence or resource is created.");
  75         NSInvokeRequest(NULL, OC_REST_DISCOVER, clientResponse->addr,
  76             NS_DISCOVER_QUERY, NULL, NSProviderDiscoverListener, NULL,
  77             clientResponse->addr->adapter);
  78     }
  79
  80     return OC_STACK_KEEP_TRANSACTION;
  81 }
  82
  83 OCStackApplicationResult NSProviderDiscoverListener(
  84         void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
  85 {
  86     (void) handle;
  87
  88     NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
  89     NS_VERIFY_NOT_NULL(clientResponse->payload, OC_STACK_KEEP_TRANSACTION);
  90     NS_VERIFY_STACK_SUCCESS(NSOCResultToSuccess(clientResponse->result), OC_STACK_KEEP_TRANSACTION);
  91
  92     NS_LOG_V(DEBUG, "Discover income : %s:%d",
  93             clientResponse->devAddr.addr, clientResponse->devAddr.port);
  94     NS_LOG_V(DEBUG, "Discover result : %d",
  95             clientResponse->result);
  96     NS_LOG_V(DEBUG, "Discover sequenceNum : %d",
  97             clientResponse->sequenceNumber);
  98     NS_LOG_V(DEBUG, "Discover Transport Type : %d",
  99                     clientResponse->devAddr.adapter);
 100
 101     if (!NSIsStartedConsumer())
 102     {
 103         return OC_STACK_DELETE_TRANSACTION;
 104     }
 105
 106     OCResourcePayload * resource = ((OCDiscoveryPayload *)clientResponse->payload)->resources;
 107     while (resource)
 108     {
 109         if (strstr(resource->uri, NS_RESOURCE_URI))
 110         {
 111             OCConnectivityType type = CT_DEFAULT;
 112             if (clientResponse->addr->adapter == OC_ADAPTER_TCP)
 113             {
 114                 type = CT_ADAPTER_TCP;
 115             }
 116
 117             NSInvokeRequest(NULL, OC_REST_GET, clientResponse->addr,
 118                     resource->uri, NULL, NSIntrospectProvider, ctx,
 119                     type);
 120         }
 121         resource = resource->next;
 122     }
 123
 124     return OC_STACK_KEEP_TRANSACTION;
 125 }
 126
 127 OCStackApplicationResult NSIntrospectProvider(
 128         void * ctx, OCDoHandle handle, OCClientResponse * clientResponse)
 129 {
 130     (void) handle;
 131
 132     NS_VERIFY_NOT_NULL(clientResponse, OC_STACK_KEEP_TRANSACTION);
 133     NS_VERIFY_STACK_SUCCESS(NSOCResultToSuccess(clientResponse->result), OC_STACK_KEEP_TRANSACTION);
 134
 135     NS_LOG_V(DEBUG, "GET response income : %s:%d",
 136             clientResponse->devAddr.addr, clientResponse->devAddr.port);
 137     NS_LOG_V(DEBUG, "GET response result : %d",
 138             clientResponse->result);
 139     NS_LOG_V(DEBUG, "GET response sequenceNum : %d",
 140             clientResponse->sequenceNumber);
 141     NS_LOG_V(DEBUG, "GET response resource uri : %s",
 142             clientResponse->resourceUri);
 143     NS_LOG_V(DEBUG, "GET response Transport Type : %d",
 144                     clientResponse->devAddr.adapter);
 145
 146     if (!NSIsStartedConsumer())
 147     {
 148         return OC_STACK_DELETE_TRANSACTION;
 149     }
 150
 151     NSProvider_internal * newProvider = NSGetProvider(clientResponse);
 152     NS_VERIFY_NOT_NULL(newProvider, OC_STACK_KEEP_TRANSACTION);
 153     if (ctx && *((NSConsumerDiscoverType *)ctx) == NS_DISCOVER_CLOUD )
 154     {
 155         newProvider->connection->isCloudConnection = true;
 156         NSOICFree(ctx);
 157     }
 158
 159     NS_LOG(DEBUG, "build NSTask");
 160     NSTask * task = NSMakeTask(TASK_CONSUMER_PROVIDER_DISCOVERED, (void *) newProvider);
 161     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(task, NS_ERROR, NSRemoveProvider(newProvider));
 162
 163     NSConsumerPushEvent(task);
 164
 165     return OC_STACK_KEEP_TRANSACTION;
 166 }
 167
 168 void NSGetProviderPostClean(
 169         char * pId, char * mUri, char * sUri, NSProviderConnectionInfo * connection)
 170 {
 171     NSOICFree(pId);
 172     NSOICFree(mUri);
 173     NSOICFree(sUri);
 174     NSRemoveConnections(connection);
 175 }
 176
 177 NSProvider_internal * NSGetProvider(OCClientResponse * clientResponse)
 178 {
 179     NS_LOG(DEBUG, "create NSProvider");
 180     NS_VERIFY_NOT_NULL(clientResponse->payload, NULL);
 181
 182     OCRepPayload * payload = (OCRepPayload *)clientResponse->payload;
 183     while (payload)
 184     {
 185         NS_LOG_V(DEBUG, "Payload Key : %s", payload->values->name);
 186         payload = payload->next;
 187     }
 188
 189     payload = (OCRepPayload *)clientResponse->payload;
 190
 191     char * providerId = NULL;
 192     char * messageUri = NULL;
 193     char * syncUri = NULL;
 194     int64_t accepter = 0;
 195     NSProviderConnectionInfo * connection = NULL;
 196
 197     NS_LOG(DEBUG, "get information of accepter");
 198     bool getResult = OCRepPayloadGetPropInt(payload, NS_ATTRIBUTE_POLICY, & accepter);
 199     NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 200
 201     NS_LOG(DEBUG, "get provider ID");
 202     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_PROVIDER_ID, & providerId);
 203     NS_VERIFY_NOT_NULL(getResult == true ? (void *) 1 : NULL, NULL);
 204
 205     NS_LOG(DEBUG, "get message URI");
 206     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_MESSAGE, & messageUri);
 207     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
 208             NSGetProviderPostClean(providerId, messageUri, syncUri, connection));
 209
 210     NS_LOG(DEBUG, "get sync URI");
 211     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_SYNC, & syncUri);
 212     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
 213             NSGetProviderPostClean(providerId, messageUri, syncUri, connection));
 214
 215     /* TODO next commit, modify code.
 216     NS_LOG(DEBUG, "get topic URI");
 217     getResult = OCRepPayloadGetPropString(payload, NS_ATTRIBUTE_TOPIC, & topicUri);
 218     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(getResult == true ? (void *) 1 : NULL, NULL,
 219             NSGetProviderPostClean(providerId, messageUri, syncUri, topicUri, connection));
 220     */
 221
 222     NS_LOG(DEBUG, "get provider connection information");
 223     NS_VERIFY_NOT_NULL(clientResponse->addr, NULL);
 224     connection = NSCreateProviderConnections(clientResponse->addr);
 225     NS_VERIFY_NOT_NULL(connection, NULL);
 226
 227     NSProvider_internal * newProvider
 228         = (NSProvider_internal *)OICMalloc(sizeof(NSProvider_internal));
 229     NS_VERIFY_NOT_NULL_WITH_POST_CLEANING(newProvider, NULL,
 230           NSGetProviderPostClean(providerId, messageUri, syncUri, connection));
 231
 232     OICStrcpy(newProvider->providerId, sizeof(char) * NS_DEVICE_ID_LENGTH, providerId);
 233     NSOICFree(providerId);
 234     newProvider->messageUri = messageUri;
 235     newProvider->syncUri = syncUri;
 236     newProvider->accessPolicy = (NSSelector)accepter;
 237     newProvider->connection = connection;
 238
 239     return newProvider;
 240 }
 241
 242 OCDevAddr * NSChangeAddress(const char * address)
 243 {
 244     NS_VERIFY_NOT_NULL(address, NULL);
 245     OCDevAddr * retAddr = NULL;
 246
 247     int index = 0;
 248     while(address[index] != '\0')
 249     {
 250         if (address[index] == ':')
 251         {
 252             break;
 253         }
 254         index++;
 255     }
 256
 257     if (address[index] == '\0')
 258     {
 259         return NULL;
 260     }
 261
 262     int tmp = index + 1;
 263     uint16_t port = address[tmp++];
 264
 265     while(address[tmp] != '\0')
 266     {
 267         port *= 10;
 268         port += address[tmp++] - '0';
 269     }
 270
 271     retAddr = (OCDevAddr *) OICMalloc(sizeof(OCDevAddr));
 272     NS_VERIFY_NOT_NULL(retAddr, NULL);
 273
 274     retAddr->adapter = OC_ADAPTER_TCP;
 275     OICStrcpy(retAddr->addr, index - 1, address);
 276     retAddr->addr[index] = '\0';
 277     retAddr->port = port;
 278
 279     return retAddr;
 280 }
 281
 282 void NSConsumerHandleRequestDiscover(OCDevAddr * address, NSConsumerDiscoverType rType)
 283 {
 284     OCConnectivityType type = CT_DEFAULT;
 285     NSConsumerDiscoverType * callbackData = NULL;
 286
 287     if (address)
 288     {
 289         if (address->adapter == OC_ADAPTER_IP)
 290         {
 291             type = CT_ADAPTER_IP;
 292             NS_LOG(DEBUG, "Request discover [UDP]");
 293         }
 294         else if (address->adapter == OC_ADAPTER_TCP)
 295         {
 296             type = CT_ADAPTER_TCP;
 297             NS_LOG(DEBUG, "Request discover and subscribe presence [TCP]");
 298             NS_LOG(DEBUG, "Subscribe presence [TCP]");
 299             NSInvokeRequest(NULL, OC_REST_PRESENCE, address, NS_PRESENCE_SUBSCRIBE_QUERY_TCP,
 300                     NULL, NSConsumerPresenceListener, NULL, type);
 301
 302             if (rType == NS_DISCOVER_CLOUD)
 303             {
 304                 callbackData = (NSConsumerDiscoverType *)OICMalloc(sizeof(NSConsumerDiscoverType));
 305                 *callbackData = NS_DISCOVER_CLOUD;
 306             }
 307         }
 308         else
 309         {
 310             NS_LOG_V(DEBUG, "Request discover But Adapter is not IP : %d", address->adapter);
 311         }
 312     }
 313     else
 314     {
 315         NS_LOG(DEBUG, "Request Multicast discover [UDP]");
 316     }
 317
 318     NSInvokeRequest(NULL, OC_REST_DISCOVER, address, NS_DISCOVER_QUERY,
 319             NULL, NSProviderDiscoverListener, (void *)callbackData, type);
 320 }
 321
 322 void NSConsumerDiscoveryTaskProcessing(NSTask * task)
 323 {
 324     NS_VERIFY_NOT_NULL_V(task);
 325
 326     NS_LOG_V(DEBUG, "Receive Event : %d", (int)task->taskType);
 327     if (task->taskType == TASK_CONSUMER_REQ_DISCOVER)
 328     {
 329         char * address = (char *) task->taskData;
 330         NSConsumerDiscoverType dType = NS_DISCOVER_DEFAULT;
 331
 332         OCDevAddr * addr = NULL;
 333         if (address)
 334         {
 335             addr = NSChangeAddress(address);
 336             dType = NS_DISCOVER_CLOUD;
 337         }
 338
 339         NSConsumerHandleRequestDiscover(addr, dType);
 340         NSOICFree(task->taskData);
 341         NSOICFree(addr);
 342     }
 343     else if (task->taskType == TASK_EVENT_CONNECTED || task->taskType == TASK_EVENT_CONNECTED_TCP)
 344     {
 345         NSConsumerHandleRequestDiscover((OCDevAddr *) task->taskData, NS_DISCOVER_DEFAULT);
 346         NSOICFree(task->taskData);
 347     }
 348     else
 349     {
 350         NS_LOG(ERROR, "Unknown type message");
 351     }
 352
 353     NSOICFree(task);
 354 }