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     }
 309     OCDiscoveryCollectionPayloadAddResource(payload, resourcePtr->tags, resourcePtr->setLinks);
 310     return OC_STACK_OK;
 311 }
 312
 313 uint8_t IsCollectionResource (OCResource *resource)
 314 {
 315     if(!resource)
 316     {
 317         return 0;
 318     }
 319
 320     for (int i = 0; i < MAX_CONTAINED_RESOURCES; i++)
 321     {
 322         if (resource->rsrcResources[i])
 323         {
 324             return 1;
 325         }
 326     }
 327     return 0;
 328 }
 329
 330 OCResource *FindResourceByUri(const char* resourceUri)
 331 {
 332     if(!resourceUri)
 333     {
 334         return NULL;
 335     }
 336
 337     OCResource * pointer = headResource;
 338     while (pointer)
 339     {
 340         if (strcmp(resourceUri, pointer->uri) == 0)
 341         {
 342             return pointer;
 343         }
 344         pointer = pointer->next;
 345     }
 346     OC_LOG_V(INFO, TAG, "Resource %s not found", resourceUri);
 347     return NULL;
 348 }
 349
 350
 351 OCStackResult DetermineResourceHandling (const OCServerRequest *request,
 352                                          ResourceHandling *handling,
 353                                          OCResource **resource)
 354 {
 355     if(!request || !handling || !resource)
 356     {
 357         return OC_STACK_INVALID_PARAM;
 358     }
 359
 360     OC_LOG_V(INFO, TAG, "DetermineResourceHandling for %s", request->resourceUrl);
 361
 362     // Check if virtual resource
 363     if (GetTypeOfVirtualURI(request->resourceUrl) != OC_UNKNOWN_URI)
 364     {
 365         OC_LOG_V (INFO, TAG, "%s is virtual", request->resourceUrl);
 366         *handling = OC_RESOURCE_VIRTUAL;
 367         *resource = headResource;
 368         return OC_STACK_OK;
 369     }
 370     if (strlen((const char*)(request->resourceUrl)) == 0)
 371     {
 372         // Resource URL not specified
 373         *handling = OC_RESOURCE_NOT_SPECIFIED;
 374         return OC_STACK_NO_RESOURCE;
 375     }
 376     else
 377     {
 378         OCResource *resourcePtr = FindResourceByUri((const char*)request->resourceUrl);
 379         *resource = resourcePtr;
 380         if (!resourcePtr)
 381         {
 382             if(defaultDeviceHandler)
 383             {
 384                 *handling = OC_RESOURCE_DEFAULT_DEVICE_ENTITYHANDLER;
 385                 return OC_STACK_OK;
 386             }
 387
 388             // Resource does not exist
 389             // and default device handler does not exist
 390             *handling = OC_RESOURCE_NOT_SPECIFIED;
 391             return OC_STACK_NO_RESOURCE;
 392         }
 393
 394         if (IsCollectionResource (resourcePtr))
 395         {
 396             // Collection resource
 397             if (resourcePtr->entityHandler != defaultResourceEHandler)
 398             {
 399                 *handling = OC_RESOURCE_COLLECTION_WITH_ENTITYHANDLER;
 400                 return OC_STACK_OK;
 401             }
 402             else
 403             {
 404                 *handling = OC_RESOURCE_COLLECTION_DEFAULT_ENTITYHANDLER;
 405                 return OC_STACK_OK;
 406             }
 407         }
 408         else
 409         {
 410             // Resource not a collection
 411             if (resourcePtr->entityHandler != defaultResourceEHandler)
 412             {
 413                 *handling = OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER;
 414                 return OC_STACK_OK;
 415             }
 416             else
 417             {
 418                 *handling = OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER;
 419                 return OC_STACK_OK;
 420             }
 421         }
 422     }
 423 }
 424
 425 OCStackResult EntityHandlerCodeToOCStackCode(OCEntityHandlerResult ehResult)
 426 {
 427     OCStackResult result;
 428
 429     switch (ehResult)
 430     {
 431         case OC_EH_OK:
 432             result = OC_STACK_OK;
 433             break;
 434         case OC_EH_SLOW:
 435             result = OC_STACK_SLOW_RESOURCE;
 436             break;
 437         case OC_EH_ERROR:
 438             result = OC_STACK_ERROR;
 439             break;
 440         case OC_EH_FORBIDDEN:
 441             result = OC_STACK_RESOURCE_ERROR;
 442             break;
 443         case OC_EH_RESOURCE_CREATED:
 444             result = OC_STACK_RESOURCE_CREATED;
 445             break;
 446         case OC_EH_RESOURCE_DELETED:
 447             result = OC_STACK_RESOURCE_DELETED;
 448             break;
 449         case OC_EH_RESOURCE_NOT_FOUND:
 450             result = OC_STACK_NO_RESOURCE;
 451             break;
 452         default:
 453             result = OC_STACK_ERROR;
 454     }
 455
 456     return result;
 457 }
 458
 459 static bool resourceMatchesRTFilter(OCResource *resource, char *resourceTypeFilter)
 460 {
 461     if (!resource)
 462     {
 463         return false;
 464     }
 465
 466     // Null or empty is analogous to no filter.
 467     if (resourceTypeFilter == NULL || *resourceTypeFilter == 0)
 468     {
 469         return true;
 470     }
 471
 472     OCResourceType *resourceTypePtr = resource->rsrcType;
 473
 474     while (resourceTypePtr)
 475     {
 476         if (strcmp (resourceTypePtr->resourcetypename, resourceTypeFilter) == 0)
 477         {
 478             return true;
 479         }
 480         resourceTypePtr = resourceTypePtr->next;
 481     }
 482
 483     OC_LOG_V(INFO, TAG, "%s does not contain rt=%s.", resource->uri, resourceTypeFilter);
 484     return false;
 485 }
 486
 487 static bool resourceMatchesIFFilter(OCResource *resource, char *interfaceFilter)
 488 {
 489     if (!resource)
 490     {
 491         return false;
 492     }
 493
 494     // Null or empty is analogous to no filter.
 495     if (interfaceFilter == NULL || *interfaceFilter == 0)
 496     {
 497         return true;
 498     }
 499
 500     OCResourceInterface *interfacePtr = resource->rsrcInterface;
 501
 502     while (interfacePtr)
 503     {
 504         if (strcmp (interfacePtr->name, interfaceFilter) == 0)
 505         {
 506             return true;
 507         }
 508         interfacePtr = interfacePtr->next;
 509     }
 510
 511     OC_LOG_V(INFO, TAG, "%s does not contain if=%s.", resource->uri, interfaceFilter);
 512     return false;
 513 }
 514
 515 /*
 516  * If the filters are null, they will be assumed to NOT be present
 517  * and the resource will not be matched against them.
 518  * Function will return true if all non null AND non empty filters passed in find a match.
 519  */
 520 static bool includeThisResourceInResponse(OCResource *resource,
 521                                                  char *interfaceFilter,
 522                                                  char *resourceTypeFilter)
 523 {
 524     if (!resource)
 525     {
 526         OC_LOG(ERROR, TAG, "Invalid resource");
 527         return false;
 528     }
 529
 530     if ( resource->resourceProperties & OC_EXPLICIT_DISCOVERABLE)
 531     {
 532         /*
 533          * At least one valid filter should be available to
 534          * include the resource in discovery response
 535          */
 536         if (!((interfaceFilter && *interfaceFilter ) ||
 537               (resourceTypeFilter && *resourceTypeFilter)))
 538         {
 539             OC_LOG_V(INFO, TAG, "%s no query string for EXPLICIT_DISCOVERABLE \
 540                 resource", resource->uri);
 541             return false;
 542         }
 543     }
 544     else if ( !(resource->resourceProperties & OC_ACTIVE) ||
 545          !(resource->resourceProperties & OC_DISCOVERABLE))
 546     {
 547         OC_LOG_V(INFO, TAG, "%s not ACTIVE or DISCOVERABLE", resource->uri);
 548         return false;
 549     }
 550
 551     return resourceMatchesIFFilter(resource, interfaceFilter) &&
 552            resourceMatchesRTFilter(resource, resourceTypeFilter);
 553
 554 }
 555
 556 OCStackResult SendNonPersistantDiscoveryResponse(OCServerRequest *request, OCResource *resource,
 557                                 OCPayload *discoveryPayload, OCEntityHandlerResult ehResult)
 558 {
 559     OCEntityHandlerResponse response = {0};
 560
 561     response.ehResult = ehResult;
 562     response.payload = discoveryPayload;
 563     response.persistentBufferFlag = 0;
 564     response.requestHandle = (OCRequestHandle) request;
 565     response.resourceHandle = (OCResourceHandle) resource;
 566
 567     return OCDoResponse(&response);
 568 }
 569
 570 #ifdef WITH_RD
 571 static OCStackResult checkResourceExistsAtRD(const char *interfaceType, const char *resourceType,
 572     OCResourceCollectionPayload **repPayload)
 573 {
 574     if (OCRDCheckPublishedResource(interfaceType, resourceType, repPayload) == OC_STACK_OK)
 575     {
 576         return OC_STACK_OK;
 577     }
 578     else
 579     {
 580         OC_LOG_V(ERROR, TAG, "The resource type or interface type doe not exist \
 581                              on the resource directory");
 582     }
 583     return OC_STACK_ERROR;
 584 }
 585 #endif
 586
 587 static OCStackResult HandleVirtualResource (OCServerRequest *request, OCResource* resource)
 588 {
 589     if (!request || !resource)
 590     {
 591         return OC_STACK_INVALID_PARAM;
 592     }
 593
 594     OCStackResult discoveryResult = OC_STACK_ERROR;
 595
 596     bool bMulticast    = false;     // Was the discovery request a multicast request?
 597     OCPayload* payload = NULL;
 598
 599     OC_LOG(INFO, TAG, "Entering HandleVirtualResource");
 600
 601     OCVirtualResources virtualUriInRequest = GetTypeOfVirtualURI (request->resourceUrl);
 602
 603     // Step 1: Generate the response to discovery request
 604     if (virtualUriInRequest == OC_WELL_KNOWN_URI)
 605     {
 606         char *filterOne = NULL;
 607         char *filterTwo = NULL;
 608
 609         discoveryResult = getQueryParamsForFiltering (virtualUriInRequest, request->query,
 610                 &filterOne, &filterTwo);
 611
 612         if (discoveryResult == OC_STACK_OK)
 613         {
 614             payload = (OCPayload*)OCDiscoveryPayloadCreate();
 615
 616             if(payload)
 617             {
 618                 bool foundResourceAtRD = false;
 619                 for(;resource && discoveryResult == OC_STACK_OK; resource = resource->next)
 620                 {
 621 #ifdef WITH_RD
 622                     if (strcmp(resource->uri, OC_RSRVD_RD_URI) == 0)
 623                     {
 624                         OCResourceCollectionPayload *repPayload;
 625                         discoveryResult = checkResourceExistsAtRD(filterOne, filterTwo, &repPayload);
 626                         if (discoveryResult != OC_STACK_OK)
 627                         {
 628                              break;
 629                         }
 630                         discoveryResult = BuildVirtualCollectionResourceResponse(repPayload,
 631                                     (OCDiscoveryPayload*)payload,
 632                                     &request->devAddr);
 633                         foundResourceAtRD = true;
 634                     }
 635 #endif
 636                     if(!foundResourceAtRD && includeThisResourceInResponse(resource, filterOne, filterTwo))
 637                     {
 638                         discoveryResult = BuildVirtualResourceResponse(resource,
 639                                 (OCDiscoveryPayload*)payload,
 640                                 &request->devAddr);
 641                     }
 642                 }
 643                 // Set discoveryResult appropriately if no 'valid' resources are available
 644                 if (((OCDiscoveryPayload*)payload)->resources == NULL && !foundResourceAtRD)
 645                 {
 646                     discoveryResult = OC_STACK_NO_RESOURCE;
 647                 }
 648             }
 649             else
 650             {
 651                 discoveryResult = OC_STACK_NO_MEMORY;
 652             }
 653         }
 654         else
 655         {
 656             OC_LOG_V(ERROR, TAG, "Error (%d) parsing query.", discoveryResult);
 657         }
 658     }
 659     else if (virtualUriInRequest == OC_DEVICE_URI)
 660     {
 661         const OicUuid_t* deviceId = OCGetServerInstanceID();
 662         if (!deviceId)
 663         {
 664             discoveryResult = OC_STACK_ERROR;
 665         }
 666         else
 667         {
 668             payload = (OCPayload*) OCDevicePayloadCreate(OC_RSRVD_DEVICE_URI,
 669                     (const uint8_t*) &deviceId->id, savedDeviceInfo.deviceName,
 670                     OC_SPEC_VERSION, OC_DATA_MODEL_VERSION);
 671             if (!payload)
 672             {
 673                 discoveryResult = OC_STACK_NO_MEMORY;
 674             }
 675             else
 676             {
 677                 discoveryResult = OC_STACK_OK;
 678             }
 679         }
 680     }
 681     else if (virtualUriInRequest == OC_PLATFORM_URI)
 682     {
 683         payload = (OCPayload*)OCPlatformPayloadCreate(
 684                 OC_RSRVD_PLATFORM_URI,
 685                 &savedPlatformInfo);
 686         if (!payload)
 687         {
 688             discoveryResult = OC_STACK_NO_MEMORY;
 689         }
 690         else
 691         {
 692             discoveryResult = OC_STACK_OK;
 693         }
 694     }
 695 #ifdef ROUTING_GATEWAY
 696     else if (OC_GATEWAY_URI == virtualUriInRequest)
 697     {
 698         // Received request for a gateway
 699         OC_LOG(INFO, TAG, "Request is for Gateway Virtual Request");
 700         discoveryResult = RMHandleGatewayRequest(request, resource);
 701
 702     }
 703 #endif
 704
 705     /**
 706      * Step 2: Send the discovery response
 707      *
 708      * Iotivity should respond to discovery requests in below manner:
 709      * 1)If query filter matching fails and discovery request is multicast,
 710      *   it should NOT send any response.
 711      * 2)If query filter matching fails and discovery request is unicast,
 712      *   it should send an error(RESOURCE_NOT_FOUND - 404) response.
 713      * 3)If Server does not have any 'DISCOVERABLE' resources and discovery
 714      *   request is multicast, it should NOT send any response.
 715      * 4)If Server does not have any 'DISCOVERABLE' resources and discovery
 716      *   request is unicast, it should send an error(RESOURCE_NOT_FOUND - 404) response.
 717      */
 718
 719 #ifdef WITH_PRESENCE
 720     if ((virtualUriInRequest == OC_PRESENCE) &&
 721         (resource->resourceProperties & OC_ACTIVE))
 722     {
 723         // Presence uses observer notification api to respond via SendPresenceNotification.
 724         SendPresenceNotification(resource->rsrcType, OC_PRESENCE_TRIGGER_CHANGE);
 725     }
 726     else
 727     #endif
 728 #ifdef ROUTING_GATEWAY
 729     // Gateway uses the RMHandleGatewayRequest to respond to the request.
 730     if (OC_GATEWAY_URI != virtualUriInRequest)
 731 #endif
 732     {
 733         if(discoveryResult == OC_STACK_OK)
 734         {
 735             SendNonPersistantDiscoveryResponse(request, resource, payload, OC_EH_OK);
 736         }
 737         else if(bMulticast == false)
 738         {
 739             OC_LOG_V(ERROR, TAG, "Sending a (%d) error to (%d)  \
 740                 discovery request", discoveryResult, virtualUriInRequest);
 741             SendNonPersistantDiscoveryResponse(request, resource, NULL,
 742                 (discoveryResult == OC_STACK_NO_RESOURCE) ? OC_EH_RESOURCE_NOT_FOUND : OC_EH_ERROR);
 743         }
 744         else
 745         {
 746             // Ignoring the discovery request as per RFC 7252, Section #8.2
 747             OC_LOG(INFO, TAG, "Silently ignoring the request since device does not have \
 748                 any useful data to send");
 749         }
 750     }
 751
 752     OCPayloadDestroy(payload);
 753
 754     return OC_STACK_OK;
 755 }
 756
 757 static OCStackResult
 758 HandleDefaultDeviceEntityHandler (OCServerRequest *request)
 759 {
 760     if(!request)
 761     {
 762         return OC_STACK_INVALID_PARAM;
 763     }
 764
 765     OCStackResult result = OC_STACK_OK;
 766     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 767     OCEntityHandlerRequest ehRequest = {0};
 768
 769     OC_LOG(INFO, TAG, "Entering HandleResourceWithDefaultDeviceEntityHandler");
 770     result = FormOCEntityHandlerRequest(&ehRequest,
 771                                         (OCRequestHandle) request,
 772                                         request->method,
 773                                         &request->devAddr,
 774                                         (OCResourceHandle) NULL, request->query,
 775                                         PAYLOAD_TYPE_REPRESENTATION,
 776                                         request->payload,
 777                                         request->payloadSize,
 778                                         request->numRcvdVendorSpecificHeaderOptions,
 779                                         request->rcvdVendorSpecificHeaderOptions,
 780                                         (OCObserveAction)request->observationOption,
 781                                         (OCObservationId)0);
 782     VERIFY_SUCCESS(result, OC_STACK_OK);
 783
 784     // At this point we know for sure that defaultDeviceHandler exists
 785     ehResult = defaultDeviceHandler(OC_REQUEST_FLAG, &ehRequest,
 786                                   (char*) request->resourceUrl, defaultDeviceHandlerCallbackParameter);
 787     if(ehResult == OC_EH_SLOW)
 788     {
 789         OC_LOG(INFO, TAG, "This is a slow resource");
 790         request->slowFlag = 1;
 791     }
 792     else if(ehResult == OC_EH_ERROR)
 793     {
 794         FindAndDeleteServerRequest(request);
 795     }
 796     result = EntityHandlerCodeToOCStackCode(ehResult);
 797 exit:
 798     OCPayloadDestroy(ehRequest.payload);
 799     return result;
 800 }
 801
 802 static OCStackResult
 803 HandleResourceWithEntityHandler (OCServerRequest *request,
 804                                  OCResource *resource,
 805                                  uint8_t collectionResource)
 806 {
 807     if(!request || ! resource)
 808     {
 809         return OC_STACK_INVALID_PARAM;
 810     }
 811
 812     OCStackResult result = OC_STACK_ERROR;
 813     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 814     OCEntityHandlerFlag ehFlag = OC_REQUEST_FLAG;
 815     ResourceObserver *resObs = NULL;
 816
 817     OCEntityHandlerRequest ehRequest = {0};
 818
 819     OC_LOG(INFO, TAG, "Entering HandleResourceWithEntityHandler");
 820     OCPayloadType type = PAYLOAD_TYPE_REPRESENTATION;
 821     // check the security resource
 822     if (request && request->resourceUrl && SRMIsSecurityResourceURI(request->resourceUrl))
 823     {
 824         type = PAYLOAD_TYPE_SECURITY;
 825
 826     }
 827
 828     if (request && strcmp(request->resourceUrl, OC_RSRVD_RD_URI) == 0)
 829     {
 830         type = PAYLOAD_TYPE_RD;
 831     }
 832
 833     result = FormOCEntityHandlerRequest(&ehRequest,
 834                                         (OCRequestHandle)request,
 835                                         request->method,
 836                                         &request->devAddr,
 837                                         (OCResourceHandle)resource,
 838                                         request->query,
 839                                         type,
 840                                         request->payload,
 841                                         request->payloadSize,
 842                                         request->numRcvdVendorSpecificHeaderOptions,
 843                                         request->rcvdVendorSpecificHeaderOptions,
 844                                         (OCObserveAction)request->observationOption,
 845                                         0);
 846     VERIFY_SUCCESS(result, OC_STACK_OK);
 847
 848     if(ehRequest.obsInfo.action == OC_OBSERVE_NO_OPTION)
 849     {
 850         OC_LOG(INFO, TAG, "No observation requested");
 851         ehFlag = OC_REQUEST_FLAG;
 852     }
 853     else if(ehRequest.obsInfo.action == OC_OBSERVE_REGISTER && !collectionResource)
 854     {
 855         OC_LOG(INFO, TAG, "Observation registration requested");
 856
 857         ResourceObserver *obs = GetObserverUsingToken (request->requestToken,
 858                                     request->tokenLength);
 859
 860         if (obs)
 861         {
 862             OC_LOG (INFO, TAG, "Observer with this token already present");
 863             OC_LOG (INFO, TAG, "Possibly re-transmitted CON OBS request");
 864             OC_LOG (INFO, TAG, "Not adding observer. Not responding to client");
 865             OC_LOG (INFO, TAG, "The first request for this token is already ACKED.");
 866
 867             // server requests are usually free'd when the response is sent out
 868             // for the request in ocserverrequest.c : HandleSingleResponse()
 869             // Since we are making an early return and not responding, the server request
 870             // needs to be deleted.
 871             FindAndDeleteServerRequest (request);
 872             return OC_STACK_OK;
 873         }
 874
 875         result = GenerateObserverId(&ehRequest.obsInfo.obsId);
 876         VERIFY_SUCCESS(result, OC_STACK_OK);
 877
 878         result = AddObserver ((const char*)(request->resourceUrl),
 879                 (const char *)(request->query),
 880                 ehRequest.obsInfo.obsId, request->requestToken, request->tokenLength,
 881                 resource, request->qos, request->acceptFormat,
 882                 &request->devAddr);
 883
 884         if(result == OC_STACK_OK)
 885         {
 886             OC_LOG(INFO, TAG, "Added observer successfully");
 887             request->observeResult = OC_STACK_OK;
 888             ehFlag = (OCEntityHandlerFlag)(OC_REQUEST_FLAG | OC_OBSERVE_FLAG);
 889         }
 890         else
 891         {
 892             result = OC_STACK_OK;
 893
 894             // The error in observeResult for the request will be used when responding to this
 895             // request by omitting the observation option/sequence number.
 896             request->observeResult = OC_STACK_ERROR;
 897             OC_LOG(ERROR, TAG, "Observer Addition failed");
 898             ehFlag = OC_REQUEST_FLAG;
 899         }
 900
 901     }
 902     else if(ehRequest.obsInfo.action == OC_OBSERVE_DEREGISTER &&
 903             !collectionResource)
 904     {
 905         OC_LOG(INFO, TAG, "Deregistering observation requested");
 906
 907         resObs = GetObserverUsingToken (request->requestToken, request->tokenLength);
 908
 909         if (NULL == resObs)
 910         {
 911             // Stack does not contain this observation request
 912             // Either token is incorrect or observation list is corrupted
 913             result = OC_STACK_ERROR;
 914             goto exit;
 915         }
 916         ehRequest.obsInfo.obsId = resObs->observeId;
 917         ehFlag = (OCEntityHandlerFlag)(ehFlag | OC_OBSERVE_FLAG);
 918
 919         result = DeleteObserverUsingToken (request->requestToken, request->tokenLength);
 920
 921         if(result == OC_STACK_OK)
 922         {
 923             OC_LOG(INFO, TAG, "Removed observer successfully");
 924             request->observeResult = OC_STACK_OK;
 925         }
 926         else
 927         {
 928             result = OC_STACK_OK;
 929             request->observeResult = OC_STACK_ERROR;
 930             OC_LOG(ERROR, TAG, "Observer Removal failed");
 931         }
 932     }
 933     else
 934     {
 935         result = OC_STACK_ERROR;
 936         goto exit;
 937     }
 938
 939     ehResult = resource->entityHandler(ehFlag, &ehRequest, resource->entityHandlerCallbackParam);
 940     if(ehResult == OC_EH_SLOW)
 941     {
 942         OC_LOG(INFO, TAG, "This is a slow resource");
 943         request->slowFlag = 1;
 944     }
 945     else if(ehResult == OC_EH_ERROR)
 946     {
 947         FindAndDeleteServerRequest(request);
 948     }
 949     result = EntityHandlerCodeToOCStackCode(ehResult);
 950 exit:
 951     OCPayloadDestroy(ehRequest.payload);
 952     return result;
 953 }
 954
 955 static OCStackResult
 956 HandleCollectionResourceDefaultEntityHandler (OCServerRequest *request,
 957                                               OCResource *resource)
 958 {
 959     if(!request || !resource)
 960     {
 961         return OC_STACK_INVALID_PARAM;
 962     }
 963
 964     OCStackResult result = OC_STACK_ERROR;
 965     OCEntityHandlerRequest ehRequest = {0};
 966
 967     result = FormOCEntityHandlerRequest(&ehRequest,
 968                                         (OCRequestHandle)request,
 969                                         request->method,
 970                                         &request->devAddr,
 971                                         (OCResourceHandle)resource,
 972                                         request->query,
 973                                         PAYLOAD_TYPE_REPRESENTATION,
 974                                         request->payload,
 975                                         request->payloadSize,
 976                                         request->numRcvdVendorSpecificHeaderOptions,
 977                                         request->rcvdVendorSpecificHeaderOptions,
 978                                         (OCObserveAction)request->observationOption,
 979                                         (OCObservationId)0);
 980     if(result == OC_STACK_OK)
 981     {
 982         result = DefaultCollectionEntityHandler (OC_REQUEST_FLAG, &ehRequest);
 983     }
 984
 985     OCPayloadDestroy(ehRequest.payload);
 986     return result;
 987 }
 988
 989 OCStackResult
 990 ProcessRequest(ResourceHandling resHandling, OCResource *resource, OCServerRequest *request)
 991 {
 992     OCStackResult ret = OC_STACK_OK;
 993
 994     switch (resHandling)
 995     {
 996         case OC_RESOURCE_VIRTUAL:
 997         {
 998             ret = HandleVirtualResource (request, resource);
 999             break;
1000         }
1001         case OC_RESOURCE_DEFAULT_DEVICE_ENTITYHANDLER:
1002         {
1003             ret = HandleDefaultDeviceEntityHandler(request);
1004             break;
1005         }
1006         case OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER:
1007         {
1008             OC_LOG(INFO, TAG, "OC_RESOURCE_NOT_COLLECTION_DEFAULT_ENTITYHANDLER");
1009             return OC_STACK_ERROR;
1010         }
1011         case OC_RESOURCE_NOT_COLLECTION_WITH_ENTITYHANDLER:
1012         {
1013             ret = HandleResourceWithEntityHandler (request, resource, 0);
1014             break;
1015         }
1016         case OC_RESOURCE_COLLECTION_WITH_ENTITYHANDLER:
1017         {
1018             ret = HandleResourceWithEntityHandler (request, resource, 1);
1019             break;
1020         }
1021         case OC_RESOURCE_COLLECTION_DEFAULT_ENTITYHANDLER:
1022         {
1023             ret = HandleCollectionResourceDefaultEntityHandler (request, resource);
1024             break;
1025         }
1026         case OC_RESOURCE_NOT_SPECIFIED:
1027         {
1028             ret = OC_STACK_NO_RESOURCE;
1029             break;
1030         }
1031         default:
1032         {
1033             OC_LOG(INFO, TAG, "Invalid Resource Determination");
1034             return OC_STACK_ERROR;
1035         }
1036     }
1037     return ret;
1038 }
1039
1040 void DeletePlatformInfo()
1041 {
1042     OC_LOG(INFO, TAG, "Deleting platform info.");
1043
1044     OICFree(savedPlatformInfo.platformID);
1045     savedPlatformInfo.platformID = NULL;
1046
1047     OICFree(savedPlatformInfo.manufacturerName);
1048     savedPlatformInfo.manufacturerName = NULL;
1049
1050     OICFree(savedPlatformInfo.manufacturerUrl);
1051     savedPlatformInfo.manufacturerUrl = NULL;
1052
1053     OICFree(savedPlatformInfo.modelNumber);
1054     savedPlatformInfo.modelNumber = NULL;
1055
1056     OICFree(savedPlatformInfo.dateOfManufacture);
1057     savedPlatformInfo.dateOfManufacture = NULL;
1058
1059     OICFree(savedPlatformInfo.platformVersion);
1060     savedPlatformInfo.platformVersion = NULL;
1061
1062     OICFree(savedPlatformInfo.operatingSystemVersion);
1063     savedPlatformInfo.operatingSystemVersion = NULL;
1064
1065     OICFree(savedPlatformInfo.hardwareVersion);
1066     savedPlatformInfo.hardwareVersion = NULL;
1067
1068     OICFree(savedPlatformInfo.firmwareVersion);
1069     savedPlatformInfo.firmwareVersion = NULL;
1070
1071     OICFree(savedPlatformInfo.supportUrl);
1072     savedPlatformInfo.supportUrl = NULL;
1073
1074     OICFree(savedPlatformInfo.systemTime);
1075     savedPlatformInfo.systemTime = NULL;
1076 }
1077
1078 static OCStackResult DeepCopyPlatFormInfo(OCPlatformInfo info)
1079 {
1080     savedPlatformInfo.platformID = OICStrdup(info.platformID);
1081     savedPlatformInfo.manufacturerName = OICStrdup(info.manufacturerName);
1082     savedPlatformInfo.manufacturerUrl = OICStrdup(info.manufacturerUrl);
1083     savedPlatformInfo.modelNumber = OICStrdup(info.modelNumber);
1084     savedPlatformInfo.dateOfManufacture = OICStrdup(info.dateOfManufacture);
1085     savedPlatformInfo.platformVersion = OICStrdup(info.platformVersion);
1086     savedPlatformInfo.operatingSystemVersion = OICStrdup(info.operatingSystemVersion);
1087     savedPlatformInfo.hardwareVersion = OICStrdup(info.hardwareVersion);
1088     savedPlatformInfo.firmwareVersion = OICStrdup(info.firmwareVersion);
1089     savedPlatformInfo.supportUrl = OICStrdup(info.supportUrl);
1090     savedPlatformInfo.systemTime = OICStrdup(info.systemTime);
1091
1092     if ((!savedPlatformInfo.platformID && info.platformID)||
1093         (!savedPlatformInfo.manufacturerName && info.manufacturerName)||
1094         (!savedPlatformInfo.manufacturerUrl && info.manufacturerUrl)||
1095         (!savedPlatformInfo.modelNumber && info.modelNumber)||
1096         (!savedPlatformInfo.dateOfManufacture && info.dateOfManufacture)||
1097         (!savedPlatformInfo.platformVersion && info.platformVersion)||
1098         (!savedPlatformInfo.operatingSystemVersion && info.operatingSystemVersion)||
1099         (!savedPlatformInfo.hardwareVersion && info.hardwareVersion)||
1100         (!savedPlatformInfo.firmwareVersion && info.firmwareVersion)||
1101         (!savedPlatformInfo.supportUrl && info.supportUrl)||
1102         (!savedPlatformInfo.systemTime && info.systemTime))
1103     {
1104         DeletePlatformInfo();
1105         return OC_STACK_INVALID_PARAM;
1106     }
1107
1108     return OC_STACK_OK;
1109
1110 }
1111
1112 OCStackResult SavePlatformInfo(OCPlatformInfo info)
1113 {
1114     DeletePlatformInfo();
1115
1116     OCStackResult res = DeepCopyPlatFormInfo(info);
1117
1118     if (res != OC_STACK_OK)
1119     {
1120         OC_LOG_V(ERROR, TAG, "Failed to save platform info. errno(%d)", res);
1121     }
1122     else
1123     {
1124         OC_LOG(INFO, TAG, "Platform info saved.");
1125     }
1126
1127     return res;
1128 }
1129
1130 void DeleteDeviceInfo()
1131 {
1132     OC_LOG(INFO, TAG, "Deleting device info.");
1133
1134     OICFree(savedDeviceInfo.deviceName);
1135     savedDeviceInfo.deviceName = NULL;
1136 }
1137
1138 static OCStackResult DeepCopyDeviceInfo(OCDeviceInfo info)
1139 {
1140     savedDeviceInfo.deviceName = OICStrdup(info.deviceName);
1141
1142     if(!savedDeviceInfo.deviceName && info.deviceName)
1143     {
1144         DeleteDeviceInfo();
1145         return OC_STACK_NO_MEMORY;
1146     }
1147
1148     return OC_STACK_OK;
1149 }
1150
1151 OCStackResult SaveDeviceInfo(OCDeviceInfo info)
1152 {
1153     OCStackResult res = OC_STACK_OK;
1154
1155     DeleteDeviceInfo();
1156
1157     res = DeepCopyDeviceInfo(info);
1158
1159     VERIFY_SUCCESS(res, OC_STACK_OK);
1160
1161     if(OCGetServerInstanceID() == NULL)
1162     {
1163         OC_LOG(INFO, TAG, "Device ID generation failed");
1164         res =  OC_STACK_ERROR;
1165         goto exit;
1166     }
1167
1168     OC_LOG(INFO, TAG, "Device initialized successfully.");
1169     return OC_STACK_OK;
1170
1171 exit:
1172     DeleteDeviceInfo();
1173     return res;
1174 }