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