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