resource/csdk/stack/src/ocresource.c

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH 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 // Defining _POSIX_C_SOURCE macro with 200112L (or greater) as value
  22 // causes header files to expose definitions
  23 // corresponding to the POSIX.1-2001 base
  24 // specification (excluding the XSI extension).
  25 // For POSIX.1-2001 base specification,
  26 // Refer http://pubs.opengroup.org/onlinepubs/009695399/
  27 #define _POSIX_C_SOURCE 200112L
  28 #include <string.h>
  29 #include "ocresource.h"
  30 #include "ocresourcehandler.h"
  31 #include "ocobserve.h"
  32 #include "occollection.h"
  33 #include "oic_malloc.h"
  34 #include "oic_string.h"
  35 #include "logger.h"
  36 #include "cJSON.h"
  37 #include "ocpayload.h"
  38 #include "secureresourcemanager.h"
  39 #include "cacommon.h"
  40 #include "cainterface.h"
  41 #include "rdpayload.h"
  42
  43 #ifdef WITH_RD
  44 #include "rd_server.h"
  45 #endif
  46
  47 #ifdef ROUTING_GATEWAY
  48 #include "routingmanager.h"
  49 #endif
  50
  51 /// Module Name
  52 #define TAG "ocresource"
  53 #define VERIFY_SUCCESS(op, successCode) { if (op != successCode) \
  54             {OC_LOG_V(FATAL, TAG, "%s failed!!", #op); goto exit;} }
  55
  56 #define VERIFY_NON_NULL(arg, logLevel, retVal) { if (!(arg)) { OC_LOG((logLevel), \
  57              TAG, #arg " is NULL"); return (retVal); } }
  58
  59 extern OCResource *headResource;
  60 static OCPlatformInfo savedPlatformInfo = {0};
  61 static OCDeviceInfo savedDeviceInfo = {0};
  62
  63 //-----------------------------------------------------------------------------
  64 // Default resource entity handler function
  65 //-----------------------------------------------------------------------------
  66 OCEntityHandlerResult defaultResourceEHandler(OCEntityHandlerFlag flag,
  67         OCEntityHandlerRequest * request, void* callbackParam)
  68 {
  69     //TODO ("Implement me!!!!");
  70     // TODO:  remove silence unused param warnings
  71     (void) flag;
  72     (void) request;
  73     (void) callbackParam;
  74     return  OC_EH_OK; // Making sure that the Default EH and the Vendor EH have matching signatures
  75 }
  76
  77 /* This method will retrieve the port at which the secure resource is hosted */
  78 static OCStackResult GetSecurePortInfo(OCDevAddr *endpoint, uint16_t *port)
  79 {
  80     uint16_t p = 0;
  81
  82     if (endpoint->adapter == OC_ADAPTER_IP)
  83     {
  84         if (endpoint->flags & OC_IP_USE_V6)
  85         {
  86             p = caglobals.ip.u6s.port;
  87         }
  88         else if (endpoint->flags & OC_IP_USE_V4)
  89         {
  90             p = caglobals.ip.u4s.port;
  91         }
  92     }
  93
  94     *port = p;
  95     return OC_STACK_OK;
  96 }
  97
  98 /*
  99  * Function will extract 0, 1 or 2 filters from query.
 100  * More than 2 filters or unsupported filters will result in error.
 101  * If both filters are of the same supported type, the 2nd one will be picked.
 102  * Resource and device filters in the SAME query are NOT validated
 103  * and resources will likely not clear filters.
 104  */
 105 static OCStackResult ExtractFiltersFromQuery(char *query, char **filterOne, char **filterTwo)
 106 {
 107
 108     char *key = NULL;
 109     char *value = NULL;
 110     char *restOfQuery = NULL;
 111     int numKeyValuePairsParsed = 0;
 112
 113     *filterOne = NULL;
 114     *filterTwo = NULL;
 115
 116     OC_LOG_V(INFO, TAG, "Extracting params from %s", query);
 117
 118     char *keyValuePair = strtok_r (query, OC_QUERY_SEPARATOR, &restOfQuery);
 119
 120     while(keyValuePair)
 121     {
 122         if (numKeyValuePairsParsed >= 2)
 123         {
 124             OC_LOG(ERROR, TAG, "More than 2 queries params in URI.");
 125             return OC_STACK_INVALID_QUERY;
 126         }
 127
 128         key = strtok_r(keyValuePair, OC_KEY_VALUE_DELIMITER, &value);
 129
 130         if (!key || !value)
 131         {
 132             return OC_STACK_INVALID_QUERY;
 133         }
 134         else if (strcmp (key, OC_RSRVD_INTERFACE) == 0)
 135         {
 136             *filterOne = value;     // if
 137         }
 138         else if (strcmp (key, OC_RSRVD_RESOURCE_TYPE) == 0)
 139         {
 140             *filterTwo = value;     // rt
 141         }
 142         else
 143         {
 144             OC_LOG_V(ERROR, TAG, "Unsupported query key: %s", key);
 145             return OC_STACK_INVALID_QUERY;
 146         }
 147         ++numKeyValuePairsParsed;
 148
 149         keyValuePair = strtok_r(NULL, OC_QUERY_SEPARATOR, &restOfQuery);
 150     }
 151
 152     OC_LOG_V(INFO, TAG, "Extracted params %s and %s.", *filterOne, *filterTwo);
 153     return OC_STACK_OK;
 154 }
 155
 156 static OCVirtualResources GetTypeOfVirtualURI(const char *uriInRequest)
 157 {
 158     if (strcmp(uriInRequest, OC_RSRVD_WELL_KNOWN_URI) == 0)
 159     {
 160         return OC_WELL_KNOWN_URI;
 161     }
 162     else if (strcmp(uriInRequest, OC_RSRVD_DEVICE_URI) == 0)
 163     {
 164         return OC_DEVICE_URI;
 165     }
 166     else if (strcmp(uriInRequest, OC_RSRVD_PLATFORM_URI) == 0)
 167     {
 168         return OC_PLATFORM_URI;
 169     }
 170     else if (strcmp(uriInRequest, OC_RSRVD_RESOURCE_TYPES_URI) == 0)
 171     {
 172         return OC_RESOURCE_TYPES_URI;
 173     }
 174 #ifdef ROUTING_GATEWAY
 175     else if (0 == strcmp(uriInRequest, OC_RSRVD_GATEWAY_URI))
 176     {
 177         return OC_GATEWAY_URI;
 178     }
 179 #endif
 180 #ifdef WITH_PRESENCE
 181     else if (strcmp(uriInRequest, OC_RSRVD_PRESENCE_URI) == 0)
 182     {
 183         return OC_PRESENCE;
 184     }
 185 #endif //WITH_PRESENCE
 186     return OC_UNKNOWN_URI;
 187 }
 188
 189 static OCStackResult getQueryParamsForFiltering (OCVirtualResources uri, char *query,
 190                                             char **filterOne, char **filterTwo)
 191 {
 192     if(!filterOne || !filterTwo)
 193     {
 194         return OC_STACK_INVALID_PARAM;
 195     }
 196
 197     *filterOne = NULL;
 198     *filterTwo = NULL;
 199
 200     #ifdef WITH_PRESENCE
 201     if (uri == OC_PRESENCE)
 202     {
 203         //Nothing needs to be done, except for pass a OC_PRESENCE query through as OC_STACK_OK.
 204         OC_LOG(INFO, TAG, "OC_PRESENCE Request for virtual resource.");
 205         return OC_STACK_OK;
 206     }
 207     #endif
 208
 209     OCStackResult result = OC_STACK_OK;
 210
 211     if (query && *query)
 212     {
 213         result = ExtractFiltersFromQuery(query, filterOne, filterTwo);
 214     }
 215
 216     return result;
 217 }
 218
 219 OCStackResult BuildResponseRepresentation(const OCResource *resourcePtr,
 220                     OCRepPayload** payload)
 221 {
 222     OCRepPayload *tempPayload = OCRepPayloadCreate();
 223
 224     if (!resourcePtr)
 225     {
 226         OCRepPayloadDestroy(tempPayload);
 227         return OC_STACK_INVALID_PARAM;
 228     }
 229
 230     if(!tempPayload)
 231     {
 232         return OC_STACK_NO_MEMORY;
 233     }
 234
 235     OCRepPayloadSetUri(tempPayload, resourcePtr->uri);
 236
 237     OCResourceType *resType = resourcePtr->rsrcType;
 238     while(resType)
 239     {
 240         OCRepPayloadAddResourceType(tempPayload, resType->resourcetypename);
 241         resType = resType->next;
 242     }
 243
 244     OCResourceInterface *resInterface = resourcePtr->rsrcInterface;
 245     while(resInterface)
 246     {
 247         OCRepPayloadAddInterface(tempPayload, resInterface->name);
 248         resInterface = resInterface->next;
 249     }
 250
 251     OCAttribute *resAttrib = resourcePtr->rsrcAttributes;
 252     while(resAttrib)
 253     {
 254         OCRepPayloadSetPropString(tempPayload, resAttrib->attrName,
 255                                 resAttrib->attrValue);
 256         resAttrib = resAttrib->next;
 257     }
 258
 259     if(!*payload)
 260     {
 261         *payload = tempPayload;
 262     }
 263     else
 264     {
 265         OCRepPayloadAppend(*payload, tempPayload);
 266     }
 267
 268     return OC_STACK_OK;
 269 }
 270
 271 OCStackResult BuildVirtualResourceResponse(const OCResource *resourcePtr,
 272                         OCDiscoveryPayload *payload, OCDevAddr *devAddr)
 273 {
 274     if (!resourcePtr || !payload)
 275     {
 276         return OC_STACK_INVALID_PARAM;
 277     }
 278     uint16_t port = 0;
 279     if (resourcePtr->resourceProperties & OC_SECURE)
 280     {
 281        if (GetSecurePortInfo(devAddr, &port) != OC_STACK_OK)
 282        {
 283            port = 0;
 284        }
 285     }
 286
 287     OCDiscoveryPayloadAddResource(payload, resourcePtr, port);
 288     return OC_STACK_OK;
 289 }
 290
 291 OCStackResult BuildVirtualCollectionResourceResponse(const OCResourceCollectionPayload *resourcePtr,
 292         OCDiscoveryPayload *payload, OCDevAddr *devAddr)
 293 {
 294     if (!resourcePtr || !payload)
 295     {
 296         return OC_STACK_INVALID_PARAM;
 297     }
 298     if (resourcePtr->tags && (resourcePtr->tags->bitmap & OC_SECURE))
 299     {
 300        if (GetSecurePortInfo(devAddr, &resourcePtr->tags->port) != OC_STACK_OK)
 301        {
 302            OC_LOG(ERROR, TAG, "Failed setting secure port.");
 303        }
 304     }
 305     if (resourcePtr->tags && !resourcePtr->tags->baseURI)
 306     {
 307         resourcePtr->tags->baseURI = OICStrdup(devAddr->addr);
 308         if (resourcePtr->tags->port == 0 && devAddr->port != 0)
 309         {
 310             resourcePtr->tags->port = devAddr->port;
 311         }
 312     }
 313     OCDiscoveryCollectionPayloadAddResource(payload, resourcePtr->tags, resourcePtr->setLinks);
 314     return OC_STACK_OK;
 315 }
 316
 317 uint8_t IsCollectionResource (OCResource *resource)
 318 {
 319     if(!resource)
 320     {
 321         return 0;
 322     }
 323
 324     for (int i = 0; i < MAX_CONTAINED_RESOURCES; i++)
 325     {
 326         if (resource->rsrcResources[i])
 327         {
 328             return 1;
 329         }
 330     }
 331     return 0;
 332 }
 333
 334 OCResource *FindResourceByUri(const char* resourceUri)
 335 {
 336     if(!resourceUri)
 337     {
 338         return NULL;
 339     }
 340
 341     OCResource * pointer = headResource;
 342     while (pointer)
 343     {
 344         if (strcmp(resourceUri, pointer->uri) == 0)
 345         {
 346             return pointer;
 347         }
 348         pointer = pointer->next;
 349     }
 350     OC_LOG_V(INFO, TAG, "Resource %s not found", resourceUri);
 351     return NULL;
 352 }
 353
 354
 355 OCStackResult DetermineResourceHandling (const OCServerRequest *request,
 356                                          ResourceHandling *handling,
 357                                          OCResource **resource)
 358 {
 359     if(!request || !handling || !resource)
 360     {
 361         return OC_STACK_INVALID_PARAM;
 362     }
 363
 364     OC_LOG_V(INFO, TAG, "DetermineResourceHandling for %s", request->resourceUrl);
 365
 366     // Check if virtual resource
 367     if (GetTypeOfVirtualURI(request->resourceUrl) != OC_UNKNOWN_URI)
 368     {
 369         OC_LOG_V (INFO, TAG, "%s is virtual", request->resourceUrl);
 370         *handling = OC_RESOURCE_VIRTUAL;
 371         *resource = headResource;
 372         return OC_STACK_OK;
 373     }
 374     if (strlen((const char*)(request->resourceUrl)) == 0)
 375     {
 376         // Resource URL not specified
 377         *handling = OC_RESOURCE_NOT_SPECIFIED;
 378         return OC_STACK_NO_RESOURCE;
 379     }
 380     else
 381     {
 382         OCResource *resourcePtr = FindResourceByUri((const char*)request->resourceUrl);
 383         *resource = resourcePtr;
 384         if (!resourcePtr)
 385         {
 386             if(defaultDeviceHandler)
 387             {
 388                 *handling = OC_RESOURCE_DEFAULT_DEVICE_ENTITYHANDLER;
 389                 return OC_STACK_OK;
 390             }
 391
 392             // Resource does not exist
 393             // and default device handler does not exist
 394             *handling = OC_RESOURCE_NOT_SPECIFIED;
 395             return OC_STACK_NO_RESOURCE;
 396         }
 397
 398         if (IsCollectionResource (resourcePtr))
 399         {
 400             // Collection resource
 401             if (resourcePtr->entityHandler != defaultResourceEHandler)
 402             {
 403                 *handling = OC_RESOURCE_COLLECTION_WITH_ENTITYHANDLER;
 404                 return OC_STACK_OK;
 405             }
 406             else
 407             {
 408                 *handling = OC_RESOURCE_COLLECTION_DEFAULT_ENTITYHANDLER;
 409                 return OC_STACK_OK;
 410             }
 411         }
 412         else
 413         {
 414             // Resource not a collection
 415             if (resourcePtr->entityHandler != defaultResourceEHandler)
 416             {
 417                 *handling = OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER;
 418                 return OC_STACK_OK;
 419             }
 420             else
 421             {
 422                 *handling = OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER;
 423                 return OC_STACK_OK;
 424             }
 425         }
 426     }
 427 }
 428
 429 OCStackResult EntityHandlerCodeToOCStackCode(OCEntityHandlerResult ehResult)
 430 {
 431     OCStackResult result;
 432
 433     switch (ehResult)
 434     {
 435         case OC_EH_OK:
 436             result = OC_STACK_OK;
 437             break;
 438         case OC_EH_SLOW:
 439             result = OC_STACK_SLOW_RESOURCE;
 440             break;
 441         case OC_EH_ERROR:
 442             result = OC_STACK_ERROR;
 443             break;
 444         case OC_EH_FORBIDDEN:
 445             result = OC_STACK_RESOURCE_ERROR;
 446             break;
 447         case OC_EH_RESOURCE_CREATED:
 448             result = OC_STACK_RESOURCE_CREATED;
 449             break;
 450         case OC_EH_RESOURCE_DELETED:
 451             result = OC_STACK_RESOURCE_DELETED;
 452             break;
 453         case OC_EH_RESOURCE_NOT_FOUND:
 454             result = OC_STACK_NO_RESOURCE;
 455             break;
 456         default:
 457             result = OC_STACK_ERROR;
 458     }
 459
 460     return result;
 461 }
 462
 463 static bool resourceMatchesRTFilter(OCResource *resource, char *resourceTypeFilter)
 464 {
 465     if (!resource)
 466     {
 467         return false;
 468     }
 469
 470     // Null or empty is analogous to no filter.
 471     if (resourceTypeFilter == NULL || *resourceTypeFilter == 0)
 472     {
 473         return true;
 474     }
 475
 476     OCResourceType *resourceTypePtr = resource->rsrcType;
 477
 478     while (resourceTypePtr)
 479     {
 480         if (strcmp (resourceTypePtr->resourcetypename, resourceTypeFilter) == 0)
 481         {
 482             return true;
 483         }
 484         resourceTypePtr = resourceTypePtr->next;
 485     }
 486
 487     OC_LOG_V(INFO, TAG, "%s does not contain rt=%s.", resource->uri, resourceTypeFilter);
 488     return false;
 489 }
 490
 491 static bool resourceMatchesIFFilter(OCResource *resource, char *interfaceFilter)
 492 {
 493     if (!resource)
 494     {
 495         return false;
 496     }
 497
 498     // Null or empty is analogous to no filter.
 499     if (interfaceFilter == NULL || *interfaceFilter == 0)
 500     {
 501         return true;
 502     }
 503
 504     OCResourceInterface *interfacePtr = resource->rsrcInterface;
 505
 506     while (interfacePtr)
 507     {
 508         if (strcmp (interfacePtr->name, interfaceFilter) == 0)
 509         {
 510             return true;
 511         }
 512         interfacePtr = interfacePtr->next;
 513     }
 514
 515     OC_LOG_V(INFO, TAG, "%s does not contain if=%s.", resource->uri, interfaceFilter);
 516     return false;
 517 }
 518
 519 /*
 520  * If the filters are null, they will be assumed to NOT be present
 521  * and the resource will not be matched against them.
 522  * Function will return true if all non null AND non empty filters passed in find a match.
 523  */
 524 static bool includeThisResourceInResponse(OCResource *resource,
 525                                                  char *interfaceFilter,
 526                                                  char *resourceTypeFilter)
 527 {
 528     if (!resource)
 529     {
 530         OC_LOG(ERROR, TAG, "Invalid resource");
 531         return false;
 532     }
 533
 534     if ( resource->resourceProperties & OC_EXPLICIT_DISCOVERABLE)
 535     {
 536         /*
 537          * At least one valid filter should be available to
 538          * include the resource in discovery response
 539          */
 540         if (!((interfaceFilter && *interfaceFilter ) ||
 541               (resourceTypeFilter && *resourceTypeFilter)))
 542         {
 543             OC_LOG_V(INFO, TAG, "%s no query string for EXPLICIT_DISCOVERABLE \
 544                 resource", resource->uri);
 545             return false;
 546         }
 547     }
 548     else if ( !(resource->resourceProperties & OC_ACTIVE) ||
 549          !(resource->resourceProperties & OC_DISCOVERABLE))
 550     {
 551         OC_LOG_V(INFO, TAG, "%s not ACTIVE or DISCOVERABLE", resource->uri);
 552         return false;
 553     }
 554
 555     return resourceMatchesIFFilter(resource, interfaceFilter) &&
 556            resourceMatchesRTFilter(resource, resourceTypeFilter);
 557
 558 }
 559
 560 OCStackResult SendNonPersistantDiscoveryResponse(OCServerRequest *request, OCResource *resource,
 561                                 OCPayload *discoveryPayload, OCEntityHandlerResult ehResult)
 562 {
 563     OCEntityHandlerResponse response = {0};
 564
 565     response.ehResult = ehResult;
 566     response.payload = discoveryPayload;
 567     response.persistentBufferFlag = 0;
 568     response.requestHandle = (OCRequestHandle) request;
 569     response.resourceHandle = (OCResourceHandle) resource;
 570
 571     return OCDoResponse(&response);
 572 }
 573
 574 #ifdef WITH_RD
 575 static OCStackResult checkResourceExistsAtRD(const char *interfaceType, const char *resourceType,
 576     OCResourceCollectionPayload **repPayload, OCDevAddr *devAddr)
 577 {
 578     if (OCRDCheckPublishedResource(interfaceType, resourceType, repPayload, devAddr) == OC_STACK_OK)
 579     {
 580         return OC_STACK_OK;
 581     }
 582     else
 583     {
 584         OC_LOG_V(ERROR, TAG, "The resource type or interface type doe not exist \
 585                              on the resource directory");
 586     }
 587     return OC_STACK_ERROR;
 588 }
 589 #endif
 590
 591 static OCStackResult HandleVirtualResource (OCServerRequest *request, OCResource* resource)
 592 {
 593     if (!request || !resource)
 594     {
 595         return OC_STACK_INVALID_PARAM;
 596     }
 597
 598     OCStackResult discoveryResult = OC_STACK_ERROR;
 599
 600     bool bMulticast    = false;     // Was the discovery request a multicast request?
 601     OCPayload* payload = NULL;
 602
 603     OC_LOG(INFO, TAG, "Entering HandleVirtualResource");
 604
 605     OCVirtualResources virtualUriInRequest = GetTypeOfVirtualURI (request->resourceUrl);
 606
 607     // Step 1: Generate the response to discovery request
 608     if (virtualUriInRequest == OC_WELL_KNOWN_URI)
 609     {
 610         char *filterOne = NULL;
 611         char *filterTwo = NULL;
 612
 613         discoveryResult = getQueryParamsForFiltering (virtualUriInRequest, request->query,
 614                 &filterOne, &filterTwo);
 615
 616         if (discoveryResult == OC_STACK_OK)
 617         {
 618             payload = (OCPayload*)OCDiscoveryPayloadCreate();
 619
 620             if(payload)
 621             {
 622                 bool foundResourceAtRD = false;
 623                 for(;resource && discoveryResult == OC_STACK_OK; resource = resource->next)
 624                 {
 625 #ifdef WITH_RD
 626                     if (strcmp(resource->uri, OC_RSRVD_RD_URI) == 0)
 627                     {
 628                         OCResourceCollectionPayload *repPayload;
 629                         OCDevAddr devAddr;
 630                         discoveryResult = checkResourceExistsAtRD(filterOne, filterTwo, &repPayload, &devAddr);
 631                         if (discoveryResult != OC_STACK_OK)
 632                         {
 633                              break;
 634                         }
 635                         discoveryResult = BuildVirtualCollectionResourceResponse(repPayload,
 636                                     (OCDiscoveryPayload*)payload,
 637                                     &devAddr);
 638                         foundResourceAtRD = true;
 639                     }
 640 #endif
 641                     if(!foundResourceAtRD && includeThisResourceInResponse(resource, filterOne, filterTwo))
 642                     {
 643                         discoveryResult = BuildVirtualResourceResponse(resource,
 644                                 (OCDiscoveryPayload*)payload,
 645                                 &request->devAddr);
 646                     }
 647                 }
 648                 // Set discoveryResult appropriately if no 'valid' resources are available
 649                 if (((OCDiscoveryPayload*)payload)->resources == NULL && !foundResourceAtRD)
 650                 {
 651                     discoveryResult = OC_STACK_NO_RESOURCE;
 652                 }
 653             }
 654             else
 655             {
 656                 discoveryResult = OC_STACK_NO_MEMORY;
 657             }
 658         }
 659         else
 660         {
 661             OC_LOG_V(ERROR, TAG, "Error (%d) parsing query.", discoveryResult);
 662         }
 663     }
 664     else if (virtualUriInRequest == OC_DEVICE_URI)
 665     {
 666         const OicUuid_t* deviceId = OCGetServerInstanceID();
 667         if (!deviceId)
 668         {
 669             discoveryResult = OC_STACK_ERROR;
 670         }
 671         else
 672         {
 673             payload = (OCPayload*) OCDevicePayloadCreate((const uint8_t*) &deviceId->id, savedDeviceInfo.deviceName,
 674                     OC_SPEC_VERSION, OC_DATA_MODEL_VERSION);
 675             if (!payload)
 676             {
 677                 discoveryResult = OC_STACK_NO_MEMORY;
 678             }
 679             else
 680             {
 681                 discoveryResult = OC_STACK_OK;
 682             }
 683         }
 684     }
 685     else if (virtualUriInRequest == OC_PLATFORM_URI)
 686     {
 687         payload = (OCPayload*)OCPlatformPayloadCreate(&savedPlatformInfo);
 688         if (!payload)
 689         {
 690             discoveryResult = OC_STACK_NO_MEMORY;
 691         }
 692         else
 693         {
 694             discoveryResult = OC_STACK_OK;
 695         }
 696     }
 697 #ifdef ROUTING_GATEWAY
 698     else if (OC_GATEWAY_URI == virtualUriInRequest)
 699     {
 700         // Received request for a gateway
 701         OC_LOG(INFO, TAG, "Request is for Gateway Virtual Request");
 702         discoveryResult = RMHandleGatewayRequest(request, resource);
 703
 704     }
 705 #endif
 706
 707     /**
 708      * Step 2: Send the discovery response
 709      *
 710      * Iotivity should respond to discovery requests in below manner:
 711      * 1)If query filter matching fails and discovery request is multicast,
 712      *   it should NOT send any response.
 713      * 2)If query filter matching fails and discovery request is unicast,
 714      *   it should send an error(RESOURCE_NOT_FOUND - 404) response.
 715      * 3)If Server does not have any 'DISCOVERABLE' resources and discovery
 716      *   request is multicast, it should NOT send any response.
 717      * 4)If Server does not have any 'DISCOVERABLE' resources and discovery
 718      *   request is unicast, it should send an error(RESOURCE_NOT_FOUND - 404) response.
 719      */
 720
 721 #ifdef WITH_PRESENCE
 722     if ((virtualUriInRequest == OC_PRESENCE) &&
 723         (resource->resourceProperties & OC_ACTIVE))
 724     {
 725         // Presence uses observer notification api to respond via SendPresenceNotification.
 726         SendPresenceNotification(resource->rsrcType, OC_PRESENCE_TRIGGER_CHANGE);
 727     }
 728     else
 729     #endif
 730 #ifdef ROUTING_GATEWAY
 731     // Gateway uses the RMHandleGatewayRequest to respond to the request.
 732     if (OC_GATEWAY != virtualUriInRequest)
 733 #endif
 734     {
 735         if(discoveryResult == OC_STACK_OK)
 736         {
 737             SendNonPersistantDiscoveryResponse(request, resource, payload, OC_EH_OK);
 738         }
 739         else if(bMulticast == false && (request->devAddr.adapter != OC_ADAPTER_RFCOMM_BTEDR) &&
 740                (request->devAddr.adapter != OC_ADAPTER_GATT_BTLE))
 741         {
 742             OC_LOG_V(ERROR, TAG, "Sending a (%d) error to (%d)  \
 743                 discovery request", discoveryResult, virtualUriInRequest);
 744             SendNonPersistantDiscoveryResponse(request, resource, NULL,
 745                 (discoveryResult == OC_STACK_NO_RESOURCE) ? OC_EH_RESOURCE_NOT_FOUND : OC_EH_ERROR);
 746         }
 747         else
 748         {
 749             // Ignoring the discovery request as per RFC 7252, Section #8.2
 750             OC_LOG(INFO, TAG, "Silently ignoring the request since device does not have \
 751                 any useful data to send");
 752         }
 753     }
 754
 755     OCPayloadDestroy(payload);
 756
 757     return OC_STACK_OK;
 758 }
 759
 760 static OCStackResult
 761 HandleDefaultDeviceEntityHandler (OCServerRequest *request)
 762 {
 763     if(!request)
 764     {
 765         return OC_STACK_INVALID_PARAM;
 766     }
 767
 768     OCStackResult result = OC_STACK_OK;
 769     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 770     OCEntityHandlerRequest ehRequest = {0};
 771
 772     OC_LOG(INFO, TAG, "Entering HandleResourceWithDefaultDeviceEntityHandler");
 773     result = FormOCEntityHandlerRequest(&ehRequest,
 774                                         (OCRequestHandle) request,
 775                                         request->method,
 776                                         &request->devAddr,
 777                                         (OCResourceHandle) NULL, request->query,
 778                                         PAYLOAD_TYPE_REPRESENTATION,
 779                                         request->payload,
 780                                         request->payloadSize,
 781                                         request->numRcvdVendorSpecificHeaderOptions,
 782                                         request->rcvdVendorSpecificHeaderOptions,
 783                                         (OCObserveAction)request->observationOption,
 784                                         (OCObservationId)0);
 785     VERIFY_SUCCESS(result, OC_STACK_OK);
 786
 787     // At this point we know for sure that defaultDeviceHandler exists
 788     ehResult = defaultDeviceHandler(OC_REQUEST_FLAG, &ehRequest,
 789                                   (char*) request->resourceUrl, defaultDeviceHandlerCallbackParameter);
 790     if(ehResult == OC_EH_SLOW)
 791     {
 792         OC_LOG(INFO, TAG, "This is a slow resource");
 793         request->slowFlag = 1;
 794     }
 795     else if(ehResult == OC_EH_ERROR)
 796     {
 797         FindAndDeleteServerRequest(request);
 798     }
 799     result = EntityHandlerCodeToOCStackCode(ehResult);
 800 exit:
 801     OCPayloadDestroy(ehRequest.payload);
 802     return result;
 803 }
 804
 805 static OCStackResult
 806 HandleResourceWithEntityHandler (OCServerRequest *request,
 807                                  OCResource *resource,
 808                                  uint8_t collectionResource)
 809 {
 810     if(!request || ! resource)
 811     {
 812         return OC_STACK_INVALID_PARAM;
 813     }
 814
 815     OCStackResult result = OC_STACK_ERROR;
 816     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 817     OCEntityHandlerFlag ehFlag = OC_REQUEST_FLAG;
 818     ResourceObserver *resObs = NULL;
 819
 820     OCEntityHandlerRequest ehRequest = {0};
 821
 822     OC_LOG(INFO, TAG, "Entering HandleResourceWithEntityHandler");
 823     OCPayloadType type = PAYLOAD_TYPE_REPRESENTATION;
 824     // check the security resource
 825     if (request && request->resourceUrl && SRMIsSecurityResourceURI(request->resourceUrl))
 826     {
 827         type = PAYLOAD_TYPE_SECURITY;
 828
 829     }
 830
 831     if (request && strcmp(request->resourceUrl, OC_RSRVD_RD_URI) == 0)
 832     {
 833         type = PAYLOAD_TYPE_RD;
 834     }
 835
 836     result = FormOCEntityHandlerRequest(&ehRequest,
 837                                         (OCRequestHandle)request,
 838                                         request->method,
 839                                         &request->devAddr,
 840                                         (OCResourceHandle)resource,
 841                                         request->query,
 842                                         type,
 843                                         request->payload,
 844                                         request->payloadSize,
 845                                         request->numRcvdVendorSpecificHeaderOptions,
 846                                         request->rcvdVendorSpecificHeaderOptions,
 847                                         (OCObserveAction)request->observationOption,
 848                                         0);
 849     VERIFY_SUCCESS(result, OC_STACK_OK);
 850
 851     if(ehRequest.obsInfo.action == OC_OBSERVE_NO_OPTION)
 852     {
 853         OC_LOG(INFO, TAG, "No observation requested");
 854         ehFlag = OC_REQUEST_FLAG;
 855     }
 856     else if(ehRequest.obsInfo.action == OC_OBSERVE_REGISTER && !collectionResource)
 857     {
 858         OC_LOG(INFO, TAG, "Observation registration requested");
 859
 860         ResourceObserver *obs = GetObserverUsingToken (request->requestToken,
 861                                     request->tokenLength);
 862
 863         if (obs)
 864         {
 865             OC_LOG (INFO, TAG, "Observer with this token already present");
 866             OC_LOG (INFO, TAG, "Possibly re-transmitted CON OBS request");
 867             OC_LOG (INFO, TAG, "Not adding observer. Not responding to client");
 868             OC_LOG (INFO, TAG, "The first request for this token is already ACKED.");
 869
 870             // server requests are usually free'd when the response is sent out
 871             // for the request in ocserverrequest.c : HandleSingleResponse()
 872             // Since we are making an early return and not responding, the server request
 873             // needs to be deleted.
 874             FindAndDeleteServerRequest (request);
 875             return OC_STACK_OK;
 876         }
 877
 878         result = GenerateObserverId(&ehRequest.obsInfo.obsId);
 879         VERIFY_SUCCESS(result, OC_STACK_OK);
 880
 881         result = AddObserver ((const char*)(request->resourceUrl),
 882                 (const char *)(request->query),
 883                 ehRequest.obsInfo.obsId, request->requestToken, request->tokenLength,
 884                 resource, request->qos, request->acceptFormat,
 885                 &request->devAddr);
 886
 887         if(result == OC_STACK_OK)
 888         {
 889             OC_LOG(INFO, TAG, "Added observer successfully");
 890             request->observeResult = OC_STACK_OK;
 891             ehFlag = (OCEntityHandlerFlag)(OC_REQUEST_FLAG | OC_OBSERVE_FLAG);
 892         }
 893         else
 894         {
 895             result = OC_STACK_OK;
 896
 897             // The error in observeResult for the request will be used when responding to this
 898             // request by omitting the observation option/sequence number.
 899             request->observeResult = OC_STACK_ERROR;
 900             OC_LOG(ERROR, TAG, "Observer Addition failed");
 901             ehFlag = OC_REQUEST_FLAG;
 902         }
 903
 904     }
 905     else if(ehRequest.obsInfo.action == OC_OBSERVE_DEREGISTER &&
 906             !collectionResource)
 907     {
 908         OC_LOG(INFO, TAG, "Deregistering observation requested");
 909
 910         resObs = GetObserverUsingToken (request->requestToken, request->tokenLength);
 911
 912         if (NULL == resObs)
 913         {
 914             // Stack does not contain this observation request
 915             // Either token is incorrect or observation list is corrupted
 916             result = OC_STACK_ERROR;
 917             goto exit;
 918         }
 919         ehRequest.obsInfo.obsId = resObs->observeId;
 920         ehFlag = (OCEntityHandlerFlag)(ehFlag | OC_OBSERVE_FLAG);
 921
 922         result = DeleteObserverUsingToken (request->requestToken, request->tokenLength);
 923
 924         if(result == OC_STACK_OK)
 925         {
 926             OC_LOG(INFO, TAG, "Removed observer successfully");
 927             request->observeResult = OC_STACK_OK;
 928         }
 929         else
 930         {
 931             result = OC_STACK_OK;
 932             request->observeResult = OC_STACK_ERROR;
 933             OC_LOG(ERROR, TAG, "Observer Removal failed");
 934         }
 935     }
 936     else
 937     {
 938         result = OC_STACK_ERROR;
 939         goto exit;
 940     }
 941
 942     ehResult = resource->entityHandler(ehFlag, &ehRequest, resource->entityHandlerCallbackParam);
 943     if(ehResult == OC_EH_SLOW)
 944     {
 945         OC_LOG(INFO, TAG, "This is a slow resource");
 946         request->slowFlag = 1;
 947     }
 948     else if(ehResult == OC_EH_ERROR)
 949     {
 950         FindAndDeleteServerRequest(request);
 951     }
 952     result = EntityHandlerCodeToOCStackCode(ehResult);
 953 exit:
 954     OCPayloadDestroy(ehRequest.payload);
 955     return result;
 956 }
 957
 958 static OCStackResult
 959 HandleCollectionResourceDefaultEntityHandler (OCServerRequest *request,
 960                                               OCResource *resource)
 961 {
 962     if(!request || !resource)
 963     {
 964         return OC_STACK_INVALID_PARAM;
 965     }
 966
 967     OCStackResult result = OC_STACK_ERROR;
 968     OCEntityHandlerRequest ehRequest = {0};
 969
 970     result = FormOCEntityHandlerRequest(&ehRequest,
 971                                         (OCRequestHandle)request,
 972                                         request->method,
 973                                         &request->devAddr,
 974                                         (OCResourceHandle)resource,
 975                                         request->query,
 976                                         PAYLOAD_TYPE_REPRESENTATION,
 977                                         request->payload,
 978                                         request->payloadSize,
 979                                         request->numRcvdVendorSpecificHeaderOptions,
 980                                         request->rcvdVendorSpecificHeaderOptions,
 981                                         (OCObserveAction)request->observationOption,
 982                                         (OCObservationId)0);
 983     if(result == OC_STACK_OK)
 984     {
 985         result = DefaultCollectionEntityHandler (OC_REQUEST_FLAG, &ehRequest);
 986     }
 987
 988     OCPayloadDestroy(ehRequest.payload);
 989     return result;
 990 }
 991
 992 OCStackResult
 993 ProcessRequest(ResourceHandling resHandling, OCResource *resource, OCServerRequest *request)
 994 {
 995     OCStackResult ret = OC_STACK_OK;
 996
 997     switch (resHandling)
 998     {
 999         case OC_RESOURCE_VIRTUAL:
1000         {
1001             ret = HandleVirtualResource (request, resource);
1002             break;
1003         }
1004         case OC_RESOURCE_DEFAULT_DEVICE_ENTITYHANDLER:
1005         {
1006             ret = HandleDefaultDeviceEntityHandler(request);
1007             break;
1008         }
1009         case OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER:
1010         {
1011             OC_LOG(INFO, TAG, "OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER");
1012             return OC_STACK_ERROR;
1013         }
1014         case OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER:
1015         {
1016             ret = HandleResourceWithEntityHandler (request, resource, 0);
1017             break;
1018         }
1019         case OC_RESOURCE_COLLECTION_WITH_ENTITYHANDLER:
1020         {
1021             ret = HandleResourceWithEntityHandler (request, resource, 1);
1022             break;
1023         }
1024         case OC_RESOURCE_COLLECTION_DEFAULT_ENTITYHANDLER:
1025         {
1026             ret = HandleCollectionResourceDefaultEntityHandler (request, resource);
1027             break;
1028         }
1029         case OC_RESOURCE_NOT_SPECIFIED:
1030         {
1031             ret = OC_STACK_NO_RESOURCE;
1032             break;
1033         }
1034         default:
1035         {
1036             OC_LOG(INFO, TAG, "Invalid Resource Determination");
1037             return OC_STACK_ERROR;
1038         }
1039     }
1040     return ret;
1041 }
1042
1043 void DeletePlatformInfo()
1044 {
1045     OC_LOG(INFO, TAG, "Deleting platform info.");
1046
1047     OICFree(savedPlatformInfo.platformID);
1048     savedPlatformInfo.platformID = NULL;
1049
1050     OICFree(savedPlatformInfo.manufacturerName);
1051     savedPlatformInfo.manufacturerName = NULL;
1052
1053     OICFree(savedPlatformInfo.manufacturerUrl);
1054     savedPlatformInfo.manufacturerUrl = NULL;
1055
1056     OICFree(savedPlatformInfo.modelNumber);
1057     savedPlatformInfo.modelNumber = NULL;
1058
1059     OICFree(savedPlatformInfo.dateOfManufacture);
1060     savedPlatformInfo.dateOfManufacture = NULL;
1061
1062     OICFree(savedPlatformInfo.platformVersion);
1063     savedPlatformInfo.platformVersion = NULL;
1064
1065     OICFree(savedPlatformInfo.operatingSystemVersion);
1066     savedPlatformInfo.operatingSystemVersion = NULL;
1067
1068     OICFree(savedPlatformInfo.hardwareVersion);
1069     savedPlatformInfo.hardwareVersion = NULL;
1070
1071     OICFree(savedPlatformInfo.firmwareVersion);
1072     savedPlatformInfo.firmwareVersion = NULL;
1073
1074     OICFree(savedPlatformInfo.supportUrl);
1075     savedPlatformInfo.supportUrl = NULL;
1076
1077     OICFree(savedPlatformInfo.systemTime);
1078     savedPlatformInfo.systemTime = NULL;
1079 }
1080
1081 static OCStackResult DeepCopyPlatFormInfo(OCPlatformInfo info)
1082 {
1083     savedPlatformInfo.platformID = OICStrdup(info.platformID);
1084     savedPlatformInfo.manufacturerName = OICStrdup(info.manufacturerName);
1085     savedPlatformInfo.manufacturerUrl = OICStrdup(info.manufacturerUrl);
1086     savedPlatformInfo.modelNumber = OICStrdup(info.modelNumber);
1087     savedPlatformInfo.dateOfManufacture = OICStrdup(info.dateOfManufacture);
1088     savedPlatformInfo.platformVersion = OICStrdup(info.platformVersion);
1089     savedPlatformInfo.operatingSystemVersion = OICStrdup(info.operatingSystemVersion);
1090     savedPlatformInfo.hardwareVersion = OICStrdup(info.hardwareVersion);
1091     savedPlatformInfo.firmwareVersion = OICStrdup(info.firmwareVersion);
1092     savedPlatformInfo.supportUrl = OICStrdup(info.supportUrl);
1093     savedPlatformInfo.systemTime = OICStrdup(info.systemTime);
1094
1095     if ((!savedPlatformInfo.platformID && info.platformID)||
1096         (!savedPlatformInfo.manufacturerName && info.manufacturerName)||
1097         (!savedPlatformInfo.manufacturerUrl && info.manufacturerUrl)||
1098         (!savedPlatformInfo.modelNumber && info.modelNumber)||
1099         (!savedPlatformInfo.dateOfManufacture && info.dateOfManufacture)||
1100         (!savedPlatformInfo.platformVersion && info.platformVersion)||
1101         (!savedPlatformInfo.operatingSystemVersion && info.operatingSystemVersion)||
1102         (!savedPlatformInfo.hardwareVersion && info.hardwareVersion)||
1103         (!savedPlatformInfo.firmwareVersion && info.firmwareVersion)||
1104         (!savedPlatformInfo.supportUrl && info.supportUrl)||
1105         (!savedPlatformInfo.systemTime && info.systemTime))
1106     {
1107         DeletePlatformInfo();
1108         return OC_STACK_INVALID_PARAM;
1109     }
1110
1111     return OC_STACK_OK;
1112
1113 }
1114
1115 OCStackResult SavePlatformInfo(OCPlatformInfo info)
1116 {
1117     DeletePlatformInfo();
1118
1119     OCStackResult res = DeepCopyPlatFormInfo(info);
1120
1121     if (res != OC_STACK_OK)
1122     {
1123         OC_LOG_V(ERROR, TAG, "Failed to save platform info. errno(%d)", res);
1124     }
1125     else
1126     {
1127         OC_LOG(INFO, TAG, "Platform info saved.");
1128     }
1129
1130     return res;
1131 }
1132
1133 void DeleteDeviceInfo()
1134 {
1135     OC_LOG(INFO, TAG, "Deleting device info.");
1136
1137     OICFree(savedDeviceInfo.deviceName);
1138     savedDeviceInfo.deviceName = NULL;
1139 }
1140
1141 static OCStackResult DeepCopyDeviceInfo(OCDeviceInfo info)
1142 {
1143     savedDeviceInfo.deviceName = OICStrdup(info.deviceName);
1144
1145     if(!savedDeviceInfo.deviceName && info.deviceName)
1146     {
1147         DeleteDeviceInfo();
1148         return OC_STACK_NO_MEMORY;
1149     }
1150
1151     return OC_STACK_OK;
1152 }
1153
1154 OCStackResult SaveDeviceInfo(OCDeviceInfo info)
1155 {
1156     OCStackResult res = OC_STACK_OK;
1157
1158     DeleteDeviceInfo();
1159
1160     res = DeepCopyDeviceInfo(info);
1161
1162     VERIFY_SUCCESS(res, OC_STACK_OK);
1163
1164     if(OCGetServerInstanceID() == NULL)
1165     {
1166         OC_LOG(INFO, TAG, "Device ID generation failed");
1167         res =  OC_STACK_ERROR;
1168         goto exit;
1169     }
1170
1171     OC_LOG(INFO, TAG, "Device initialized successfully.");
1172     return OC_STACK_OK;
1173
1174 exit:
1175     DeleteDeviceInfo();
1176     return res;
1177 }