resource/csdk/stack/src/ocstack.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
  22 //-----------------------------------------------------------------------------
  23 // Includes
  24 //-----------------------------------------------------------------------------
  25
  26 // Defining _POSIX_C_SOURCE macro with 200112L (or greater) as value
  27 // causes header files to expose definitions
  28 // corresponding to the POSIX.1-2001 base
  29 // specification (excluding the XSI extension).
  30 // For POSIX.1-2001 base specification,
  31 // Refer http://pubs.opengroup.org/onlinepubs/009695399/
  32 #define _POSIX_C_SOURCE 200112L
  33 #ifndef __STDC_FORMAT_MACROS
  34 #define __STDC_FORMAT_MACROS
  35 #endif
  36 #ifndef __STDC_LIMIT_MACROS
  37 #define __STDC_LIMIT_MACROS
  38 #endif
  39 #include "iotivity_config.h"
  40 #include <inttypes.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43
  44 #include "ocstack.h"
  45 #include "ocstackinternal.h"
  46 #include "ocresourcehandler.h"
  47 #include "occlientcb.h"
  48 #include "ocobserve.h"
  49 #include "ocrandom.h"
  50 #include "oic_malloc.h"
  51 #include "oic_string.h"
  52 #include "logger.h"
  53 #include "ocserverrequest.h"
  54 #include "secureresourcemanager.h"
  55 #include "psinterface.h"
  56 #include "doxmresource.h"
  57 #include "cacommon.h"
  58 #include "cainterface.h"
  59 #include "ocpayload.h"
  60 #include "ocpayloadcbor.h"
  61 #include "cautilinterface.h"
  62 #include "oicgroup.h"
  63
  64 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
  65 #include "routingutility.h"
  66 #ifdef ROUTING_GATEWAY
  67 #include "routingmanager.h"
  68 #endif
  69 #endif
  70
  71 #ifdef TCP_ADAPTER
  72 #include "oickeepalive.h"
  73 #endif
  74
  75 //#ifdef DIRECT_PAIRING
  76 #include "directpairing.h"
  77 //#endif
  78
  79 #ifdef HAVE_ARDUINO_TIME_H
  80 #include "Time.h"
  81 #endif
  82 #ifdef HAVE_SYS_TIME_H
  83 #include <sys/time.h>
  84 #endif
  85 #include <coap/coap.h>
  86
  87 #ifdef HAVE_ARPA_INET_H
  88 #include <arpa/inet.h>
  89 #endif
  90
  91 #ifndef UINT32_MAX
  92 #define UINT32_MAX   (0xFFFFFFFFUL)
  93 #endif
  94
  95 //-----------------------------------------------------------------------------
  96 // Typedefs
  97 //-----------------------------------------------------------------------------
  98 typedef enum
  99 {
 100     OC_STACK_UNINITIALIZED = 0,
 101     OC_STACK_INITIALIZED,
 102     OC_STACK_UNINIT_IN_PROGRESS
 103 } OCStackState;
 104
 105 #ifdef WITH_PRESENCE
 106 typedef enum
 107 {
 108     OC_PRESENCE_UNINITIALIZED = 0,
 109     OC_PRESENCE_INITIALIZED
 110 } OCPresenceState;
 111 #endif
 112
 113 //-----------------------------------------------------------------------------
 114 // Private variables
 115 //-----------------------------------------------------------------------------
 116 static OCStackState stackState = OC_STACK_UNINITIALIZED;
 117
 118 OCResource *headResource = NULL;
 119 static OCResource *tailResource = NULL;
 120 static OCResourceHandle platformResource = {0};
 121 static OCResourceHandle deviceResource = {0};
 122 #ifdef MQ_BROKER
 123 static OCResourceHandle brokerResource = {0};
 124 #endif
 125
 126 #ifdef WITH_PRESENCE
 127 static OCPresenceState presenceState = OC_PRESENCE_UNINITIALIZED;
 128 static PresenceResource presenceResource = {0};
 129 static uint8_t PresenceTimeOutSize = 0;
 130 static uint32_t PresenceTimeOut[] = {50, 75, 85, 95, 100};
 131 #endif
 132
 133 static OCMode myStackMode;
 134 #ifdef RA_ADAPTER
 135 //TODO: revisit this design
 136 static bool gRASetInfo = false;
 137 #endif
 138 OCDeviceEntityHandler defaultDeviceHandler;
 139 void* defaultDeviceHandlerCallbackParameter = NULL;
 140 static const char COAP_TCP_SCHEME[] = "coap+tcp:";
 141 static const char COAPS_TCP_SCHEME[] = "coaps+tcp:";
 142 static const char CORESPEC[] = "core";
 143
 144 CAAdapterStateChangedCB g_adapterHandler = NULL;
 145 CAConnectionStateChangedCB g_connectionHandler = NULL;
 146
 147 //-----------------------------------------------------------------------------
 148 // Macros
 149 //-----------------------------------------------------------------------------
 150 #define TAG  "OIC_RI_STACK"
 151 #define VERIFY_SUCCESS(op, successCode) { if ((op) != (successCode)) \
 152             {OIC_LOG_V(FATAL, TAG, "%s failed!!", #op); goto exit;} }
 153 #define VERIFY_NON_NULL(arg, logLevel, retVal) { if (!(arg)) { OIC_LOG((logLevel), \
 154              TAG, #arg " is NULL"); return (retVal); } }
 155 #define VERIFY_NON_NULL_NR(arg, logLevel) { if (!(arg)) { OIC_LOG((logLevel), \
 156              TAG, #arg " is NULL"); return; } }
 157 #define VERIFY_NON_NULL_V(arg) { if (!arg) {OIC_LOG(FATAL, TAG, #arg " is NULL");\
 158     goto exit;} }
 159
 160 //TODO: we should allow the server to define this
 161 #define MAX_OBSERVE_AGE (0x2FFFFUL)
 162
 163 #define MILLISECONDS_PER_SECOND   (1000)
 164
 165 //-----------------------------------------------------------------------------
 166 // Private internal function prototypes
 167 //-----------------------------------------------------------------------------
 168
 169 /**
 170  * Generate handle of OCDoResource invocation for callback management.
 171  *
 172  * @return Generated OCDoResource handle.
 173  */
 174 static OCDoHandle GenerateInvocationHandle();
 175
 176 /**
 177  * Initialize resource data structures, variables, etc.
 178  *
 179  * @return ::OC_STACK_OK on success, some other value upon failure.
 180  */
 181 static OCStackResult initResources();
 182
 183 /**
 184  * Add a resource to the end of the linked list of resources.
 185  *
 186  * @param resource Resource to be added
 187  */
 188 static void insertResource(OCResource *resource);
 189
 190 /**
 191  * Find a resource in the linked list of resources.
 192  *
 193  * @param resource Resource to be found.
 194  * @return Pointer to resource that was found in the linked list or NULL if the resource was not
 195  *         found.
 196  */
 197 static OCResource *findResource(OCResource *resource);
 198
 199 /**
 200  * Insert a resource type into a resource's resource type linked list.
 201  * If resource type already exists, it will not be inserted and the
 202  * resourceType will be free'd.
 203  * resourceType->next should be null to avoid memory leaks.
 204  * Function returns silently for null args.
 205  *
 206  * @param resource Resource where resource type is to be inserted.
 207  * @param resourceType Resource type to be inserted.
 208  */
 209 static void insertResourceType(OCResource *resource,
 210         OCResourceType *resourceType);
 211
 212 /**
 213  * Get a resource type at the specified index within a resource.
 214  *
 215  * @param handle Handle of resource.
 216  * @param index Index of resource type.
 217  *
 218  * @return Pointer to resource type if found, NULL otherwise.
 219  */
 220 static OCResourceType *findResourceTypeAtIndex(OCResourceHandle handle,
 221         uint8_t index);
 222
 223 /**
 224  * Insert a resource interface into a resource's resource interface linked list.
 225  * If resource interface already exists, it will not be inserted and the
 226  * resourceInterface will be free'd.
 227  * resourceInterface->next should be null to avoid memory leaks.
 228  *
 229  * @param resource Resource where resource interface is to be inserted.
 230  * @param resourceInterface Resource interface to be inserted.
 231  */
 232 static void insertResourceInterface(OCResource *resource,
 233         OCResourceInterface *resourceInterface);
 234
 235 /**
 236  * Get a resource interface at the specified index within a resource.
 237  *
 238  * @param handle Handle of resource.
 239  * @param index Index of resource interface.
 240  *
 241  * @return Pointer to resource interface if found, NULL otherwise.
 242  */
 243 static OCResourceInterface *findResourceInterfaceAtIndex(
 244         OCResourceHandle handle, uint8_t index);
 245
 246 /**
 247  * Delete all of the dynamically allocated elements that were created for the resource type.
 248  *
 249  * @param resourceType Specified resource type.
 250  */
 251 static void deleteResourceType(OCResourceType *resourceType);
 252
 253 /**
 254  * Delete all of the dynamically allocated elements that were created for the resource interface.
 255  *
 256  * @param resourceInterface Specified resource interface.
 257  */
 258 static void deleteResourceInterface(OCResourceInterface *resourceInterface);
 259
 260 /**
 261  * Delete all of the dynamically allocated elements that were created for the resource.
 262  *
 263  * @param resource Specified resource.
 264  */
 265 static void deleteResourceElements(OCResource *resource);
 266
 267 /**
 268  * Delete resource specified by handle.  Deletes resource and all resourcetype and resourceinterface
 269  * linked lists.
 270  *
 271  * @param handle Handle of resource to be deleted.
 272  *
 273  * @return ::OC_STACK_OK on success, some other value upon failure.
 274  */
 275 static OCStackResult deleteResource(OCResource *resource);
 276
 277 /**
 278  * Delete all of the resources in the resource list.
 279  */
 280 static void deleteAllResources();
 281
 282 /**
 283  * Increment resource sequence number.  Handles rollover.
 284  *
 285  * @param resPtr Pointer to resource.
 286  */
 287 static void incrementSequenceNumber(OCResource * resPtr);
 288
 289 /*
 290  * Attempts to initialize every network interface that the CA Layer might have compiled in.
 291  *
 292  * Note: At least one interface must succeed to initialize. If all calls to @ref CASelectNetwork
 293  * return something other than @ref CA_STATUS_OK, then this function fails.
 294  *
 295  * @return ::CA_STATUS_OK on success, some other value upon failure.
 296  */
 297 static CAResult_t OCSelectNetwork();
 298
 299 /**
 300  * Get the CoAP ticks after the specified number of milli-seconds.
 301  *
 302  * @param afterMilliSeconds Milli-seconds.
 303  * @return
 304  *     CoAP ticks
 305  */
 306 static uint32_t GetTicks(uint32_t afterMilliSeconds);
 307
 308 /**
 309  * Convert CAResult_t to OCStackResult.
 310  *
 311  * @param caResult CAResult_t code.
 312  * @return ::OC_STACK_OK on success, some other value upon failure.
 313  */
 314 static OCStackResult CAResultToOCStackResult(CAResult_t caResult);
 315
 316 /**
 317  * Convert CAResponseResult_t to OCStackResult.
 318  *
 319  * @param caCode CAResponseResult_t code.
 320  * @return ::OC_STACK_OK on success, some other value upon failure.
 321  */
 322 static OCStackResult CAResponseToOCStackResult(CAResponseResult_t caCode);
 323
 324 /**
 325  * Convert OCStackResult to CAResponseResult_t.
 326  *
 327  * @param caCode OCStackResult code.
 328  * @param method OCMethod method the return code replies to.
 329  * @return ::CA_CONTENT on OK, some other value upon failure.
 330  */
 331 static CAResponseResult_t OCToCAStackResult(OCStackResult ocCode, OCMethod method);
 332
 333 /**
 334  * Convert OCTransportFlags_t to CATransportModifiers_t.
 335  *
 336  * @param ocConType OCTransportFlags_t input.
 337  * @return CATransportFlags
 338  */
 339 static CATransportFlags_t OCToCATransportFlags(OCTransportFlags ocConType);
 340
 341 /**
 342  * Convert CATransportFlags_t to OCTransportModifiers_t.
 343  *
 344  * @param caConType CATransportFlags_t input.
 345  * @return OCTransportFlags
 346  */
 347 static OCTransportFlags CAToOCTransportFlags(CATransportFlags_t caConType);
 348
 349 /**
 350  * Handle response from presence request.
 351  *
 352  * @param endPoint CA remote endpoint.
 353  * @param responseInfo CA response info.
 354  * @return ::OC_STACK_OK on success, some other value upon failure.
 355  */
 356 static OCStackResult HandlePresenceResponse(const CAEndpoint_t *endPoint,
 357         const CAResponseInfo_t *responseInfo);
 358
 359 /**
 360  * This function will be called back by CA layer when a response is received.
 361  *
 362  * @param endPoint CA remote endpoint.
 363  * @param responseInfo CA response info.
 364  */
 365 static void HandleCAResponses(const CAEndpoint_t* endPoint,
 366         const CAResponseInfo_t* responseInfo);
 367
 368 /**
 369  * This function will be called back by CA layer when a request is received.
 370  *
 371  * @param endPoint CA remote endpoint.
 372  * @param requestInfo CA request info.
 373  */
 374 static void HandleCARequests(const CAEndpoint_t* endPoint,
 375         const CARequestInfo_t* requestInfo);
 376
 377 /**
 378  * Extract query from a URI.
 379  *
 380  * @param uri Full URI with query.
 381  * @param query Pointer to string that will contain query.
 382  * @param newURI Pointer to string that will contain URI.
 383  * @return ::OC_STACK_OK on success, some other value upon failure.
 384  */
 385 static OCStackResult getQueryFromUri(const char * uri, char** resourceType, char ** newURI);
 386
 387 /**
 388  * Finds a resource type in an OCResourceType link-list.
 389  *
 390  * @param resourceTypeList The link-list to be searched through.
 391  * @param resourceTypeName The key to search for.
 392  *
 393  * @return Resource type that matches the key (ie. resourceTypeName) or
 394  *      NULL if there is either an invalid parameter or this function was unable to find the key.
 395  */
 396 static OCResourceType *findResourceType(OCResourceType * resourceTypeList,
 397         const char * resourceTypeName);
 398
 399 /**
 400  * Reset presence TTL for a ClientCB struct. ttlLevel will be set to 0.
 401  * TTL will be set to maxAge.
 402  *
 403  * @param cbNode Callback Node for which presence ttl is to be reset.
 404  * @param maxAge New value of ttl in seconds.
 405
 406  * @return ::OC_STACK_OK on success, some other value upon failure.
 407  */
 408 static OCStackResult ResetPresenceTTL(ClientCB *cbNode, uint32_t maxAgeSeconds);
 409
 410 /**
 411  * Ensure the accept header option is set appropriatly before sending the requests and routing
 412  * header option is updated with destination.
 413  *
 414  * @param object CA remote endpoint.
 415  * @param requestInfo CA request info.
 416  *
 417  * @return ::OC_STACK_OK on success, some other value upon failure.
 418  */
 419 static OCStackResult OCSendRequest(const CAEndpoint_t *object, CARequestInfo_t *requestInfo);
 420
 421 /**
 422  * default adapter state change callback method
 423  *
 424  * @param adapter   CA network adapter type.
 425  * @param enabled   current adapter state.
 426  */
 427 static void OCDefaultAdapterStateChangedHandler(CATransportAdapter_t adapter, bool enabled);
 428
 429 /**
 430  * default connection state change callback method
 431  *
 432  * @param info          CAEndpoint which has address, port and etc.
 433  * @param isConnected   current connection state.
 434  */
 435 static void OCDefaultConnectionStateChangedHandler(const CAEndpoint_t *info, bool isConnected);
 436
 437 /**
 438  * Register network monitoring callback.
 439  * Network status changes are delivered these callback.
 440  * @param adapterHandler        Adapter state monitoring callback.
 441  * @param connectionHandler     Connection state monitoring callback.
 442  */
 443 static void OCSetNetworkMonitorHandler(CAAdapterStateChangedCB adapterHandler,
 444                                        CAConnectionStateChangedCB connectionHandler);
 445
 446 //-----------------------------------------------------------------------------
 447 // Internal functions
 448 //-----------------------------------------------------------------------------
 449
 450 bool checkProxyUri(OCHeaderOption *options, uint8_t numOptions)
 451 {
 452     if (!options || 0 == numOptions)
 453     {
 454         OIC_LOG (INFO, TAG, "No options present");
 455         return false;
 456     }
 457
 458     for (uint8_t i = 0; i < numOptions; i++)
 459     {
 460         if (options[i].protocolID == OC_COAP_ID && options[i].optionID == OC_RSRVD_PROXY_OPTION_ID)
 461         {
 462             OIC_LOG(DEBUG, TAG, "Proxy URI is present");
 463             return true;
 464         }
 465     }
 466     return false;
 467 }
 468
 469 uint32_t GetTicks(uint32_t afterMilliSeconds)
 470 {
 471     coap_tick_t now;
 472     coap_ticks(&now);
 473
 474     // Guard against overflow of uint32_t
 475     if (afterMilliSeconds <= ((UINT32_MAX - (uint32_t)now) * MILLISECONDS_PER_SECOND) /
 476                              COAP_TICKS_PER_SECOND)
 477     {
 478         return now + (afterMilliSeconds * COAP_TICKS_PER_SECOND)/MILLISECONDS_PER_SECOND;
 479     }
 480     else
 481     {
 482         return UINT32_MAX;
 483     }
 484 }
 485
 486 void CopyEndpointToDevAddr(const CAEndpoint_t *in, OCDevAddr *out)
 487 {
 488     VERIFY_NON_NULL_NR(in, FATAL);
 489     VERIFY_NON_NULL_NR(out, FATAL);
 490
 491     out->adapter = (OCTransportAdapter)in->adapter;
 492     out->flags = CAToOCTransportFlags(in->flags);
 493     OICStrcpy(out->addr, sizeof(out->addr), in->addr);
 494     out->port = in->port;
 495     out->ifindex = in->ifindex;
 496 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
 497     /* This assert is to prevent accidental mismatch between address size macros defined in
 498      * RI and CA and cause crash here. */
 499     OC_STATIC_ASSERT(MAX_ADDR_STR_SIZE_CA == MAX_ADDR_STR_SIZE,
 500                                         "Address size mismatch between RI and CA");
 501     memcpy(out->routeData, in->routeData, sizeof(in->routeData));
 502 #endif
 503 }
 504
 505 void CopyDevAddrToEndpoint(const OCDevAddr *in, CAEndpoint_t *out)
 506 {
 507     VERIFY_NON_NULL_NR(in, FATAL);
 508     VERIFY_NON_NULL_NR(out, FATAL);
 509
 510     out->adapter = (CATransportAdapter_t)in->adapter;
 511     out->flags = OCToCATransportFlags(in->flags);
 512     OICStrcpy(out->addr, sizeof(out->addr), in->addr);
 513 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
 514     /* This assert is to prevent accidental mismatch between address size macros defined in
 515      * RI and CA and cause crash here. */
 516     OC_STATIC_ASSERT(MAX_ADDR_STR_SIZE_CA == MAX_ADDR_STR_SIZE,
 517                                         "Address size mismatch between RI and CA");
 518     memcpy(out->routeData, in->routeData, sizeof(in->routeData));
 519 #endif
 520     out->port = in->port;
 521     out->ifindex = in->ifindex;
 522 }
 523
 524 void FixUpClientResponse(OCClientResponse *cr)
 525 {
 526     VERIFY_NON_NULL_NR(cr, FATAL);
 527
 528     cr->addr = &cr->devAddr;
 529     cr->connType = (OCConnectivityType)
 530         ((cr->devAddr.adapter << CT_ADAPTER_SHIFT) | (cr->devAddr.flags & CT_MASK_FLAGS));
 531 }
 532
 533 static OCStackResult OCSendRequest(const CAEndpoint_t *object, CARequestInfo_t *requestInfo)
 534 {
 535     VERIFY_NON_NULL(object, FATAL, OC_STACK_INVALID_PARAM);
 536     VERIFY_NON_NULL(requestInfo, FATAL, OC_STACK_INVALID_PARAM);
 537
 538 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
 539     OCStackResult rmResult = RMAddInfo(object->routeData, requestInfo, true, NULL);
 540     if (OC_STACK_OK != rmResult)
 541     {
 542         OIC_LOG(ERROR, TAG, "Add destination option failed");
 543         return rmResult;
 544     }
 545 #endif
 546
 547     // OC stack prefer CBOR encoded payloads.
 548     requestInfo->info.acceptFormat = CA_FORMAT_APPLICATION_CBOR;
 549     CAResult_t result = CASendRequest(object, requestInfo);
 550     if(CA_STATUS_OK != result)
 551     {
 552         OIC_LOG_V(ERROR, TAG, "CASendRequest failed with CA error %u", result);
 553         return CAResultToOCResult(result);
 554     }
 555     return OC_STACK_OK;
 556 }
 557 //-----------------------------------------------------------------------------
 558 // Internal API function
 559 //-----------------------------------------------------------------------------
 560
 561 // This internal function is called to update the stack with the status of
 562 // observers and communication failures
 563 OCStackResult OCStackFeedBack(CAToken_t token, uint8_t tokenLength, uint8_t status)
 564 {
 565     OCStackResult result = OC_STACK_ERROR;
 566     ResourceObserver * observer = NULL;
 567     OCEntityHandlerRequest ehRequest = {0};
 568
 569     switch(status)
 570     {
 571     case OC_OBSERVER_NOT_INTERESTED:
 572         OIC_LOG(DEBUG, TAG, "observer not interested in our notifications");
 573         observer = GetObserverUsingToken (token, tokenLength);
 574         if(observer)
 575         {
 576             result = FormOCEntityHandlerRequest(&ehRequest,
 577                                                 (OCRequestHandle)NULL,
 578                                                 OC_REST_NOMETHOD,
 579                                                 &observer->devAddr,
 580                                                 (OCResourceHandle)NULL,
 581                                                 NULL, PAYLOAD_TYPE_REPRESENTATION,
 582                                                 NULL, 0, 0, NULL,
 583                                                 OC_OBSERVE_DEREGISTER,
 584                                                 observer->observeId,
 585                                                 0);
 586             if(result != OC_STACK_OK)
 587             {
 588                 return result;
 589             }
 590             observer->resource->entityHandler(OC_OBSERVE_FLAG, &ehRequest,
 591                             observer->resource->entityHandlerCallbackParam);
 592         }
 593
 594         result = DeleteObserverUsingToken (token, tokenLength);
 595         if(result == OC_STACK_OK)
 596         {
 597             OIC_LOG(DEBUG, TAG, "Removed observer successfully");
 598         }
 599         else
 600         {
 601             result = OC_STACK_OK;
 602             OIC_LOG(DEBUG, TAG, "Observer Removal failed");
 603         }
 604         break;
 605
 606     case OC_OBSERVER_STILL_INTERESTED:
 607         OIC_LOG(DEBUG, TAG, "observer still interested, reset the failedCount");
 608         observer = GetObserverUsingToken (token, tokenLength);
 609         if(observer)
 610         {
 611             observer->forceHighQos = 0;
 612             observer->failedCommCount = 0;
 613             result = OC_STACK_OK;
 614         }
 615         else
 616         {
 617             result = OC_STACK_OBSERVER_NOT_FOUND;
 618         }
 619         break;
 620
 621     case OC_OBSERVER_FAILED_COMM:
 622         OIC_LOG(DEBUG, TAG, "observer is unreachable");
 623         observer = GetObserverUsingToken (token, tokenLength);
 624         if(observer)
 625         {
 626             if(observer->failedCommCount >= MAX_OBSERVER_FAILED_COMM)
 627             {
 628                 result = FormOCEntityHandlerRequest(&ehRequest,
 629                                                     (OCRequestHandle)NULL,
 630                                                     OC_REST_NOMETHOD,
 631                                                     &observer->devAddr,
 632                                                     (OCResourceHandle)NULL,
 633                                                     NULL, PAYLOAD_TYPE_REPRESENTATION,
 634                                                     NULL, 0, 0, NULL,
 635                                                     OC_OBSERVE_DEREGISTER,
 636                                                     observer->observeId,
 637                                                     0);
 638                 if(result != OC_STACK_OK)
 639                 {
 640                     return OC_STACK_ERROR;
 641                 }
 642                 observer->resource->entityHandler(OC_OBSERVE_FLAG, &ehRequest,
 643                                     observer->resource->entityHandlerCallbackParam);
 644
 645                 result = DeleteObserverUsingToken (token, tokenLength);
 646                 if(result == OC_STACK_OK)
 647                 {
 648                     OIC_LOG(DEBUG, TAG, "Removed observer successfully");
 649                 }
 650                 else
 651                 {
 652                     result = OC_STACK_OK;
 653                     OIC_LOG(DEBUG, TAG, "Observer Removal failed");
 654                 }
 655             }
 656             else
 657             {
 658                 observer->failedCommCount++;
 659                 result = OC_STACK_CONTINUE;
 660             }
 661             observer->forceHighQos = 1;
 662             OIC_LOG_V(DEBUG, TAG, "Failed count for this observer is %d",observer->failedCommCount);
 663         }
 664         break;
 665     default:
 666         OIC_LOG(ERROR, TAG, "Unknown status");
 667         result = OC_STACK_ERROR;
 668         break;
 669         }
 670     return result;
 671 }
 672
 673 static OCStackResult CAResultToOCStackResult(CAResult_t caResult)
 674 {
 675     OCStackResult ret = OC_STACK_ERROR;
 676
 677     switch(caResult)
 678     {
 679         case CA_ADAPTER_NOT_ENABLED:
 680         case CA_SERVER_NOT_STARTED:
 681             ret = OC_STACK_ADAPTER_NOT_ENABLED;
 682             break;
 683         case CA_MEMORY_ALLOC_FAILED:
 684             ret = OC_STACK_NO_MEMORY;
 685             break;
 686         case CA_STATUS_INVALID_PARAM:
 687             ret = OC_STACK_INVALID_PARAM;
 688             break;
 689         default:
 690             break;
 691     }
 692     return ret;
 693 }
 694
 695 OCStackResult CAResponseToOCStackResult(CAResponseResult_t caCode)
 696 {
 697     OCStackResult ret = OC_STACK_ERROR;
 698     switch(caCode)
 699     {
 700         case CA_CREATED:
 701             ret = OC_STACK_RESOURCE_CREATED;
 702             break;
 703         case CA_DELETED:
 704             ret = OC_STACK_RESOURCE_DELETED;
 705             break;
 706         case CA_CHANGED:
 707             ret = OC_STACK_RESOURCE_CHANGED;
 708             break;
 709         case CA_CONTENT:
 710         case CA_VALID:
 711             ret = OC_STACK_OK;
 712             break;
 713         case CA_BAD_REQ:
 714             ret = OC_STACK_INVALID_QUERY;
 715             break;
 716         case CA_UNAUTHORIZED_REQ:
 717             ret = OC_STACK_UNAUTHORIZED_REQ;
 718             break;
 719         case CA_BAD_OPT:
 720             ret = OC_STACK_INVALID_OPTION;
 721             break;
 722         case CA_NOT_FOUND:
 723             ret = OC_STACK_NO_RESOURCE;
 724             break;
 725         case CA_RETRANSMIT_TIMEOUT:
 726             ret = OC_STACK_COMM_ERROR;
 727             break;
 728         case CA_REQUEST_ENTITY_TOO_LARGE:
 729             ret = OC_STACK_TOO_LARGE_REQ;
 730             break;
 731         default:
 732             break;
 733     }
 734     return ret;
 735 }
 736
 737 CAResponseResult_t OCToCAStackResult(OCStackResult ocCode, OCMethod method)
 738 {
 739     CAResponseResult_t ret = CA_INTERNAL_SERVER_ERROR;
 740
 741     switch(ocCode)
 742     {
 743         case OC_STACK_OK:
 744            switch (method)
 745            {
 746                case OC_REST_PUT:
 747                case OC_REST_POST:
 748                    // This Response Code is like HTTP 204 "No Content" but only used in
 749                    // response to POST and PUT requests.
 750                    ret = CA_CHANGED;
 751                    break;
 752                case OC_REST_GET:
 753                    // This Response Code is like HTTP 200 "OK" but only used in response to
 754                    // GET requests.
 755                    ret = CA_CONTENT;
 756                    break;
 757                default:
 758                    // This should not happen but,
 759                    // give it a value just in case but output an error
 760                    ret = CA_CONTENT;
 761                    OIC_LOG_V(ERROR, TAG, "Unexpected OC_STACK_OK return code for method [%d].",
 762                             method);
 763             }
 764             break;
 765         case OC_STACK_RESOURCE_CREATED:
 766             ret = CA_CREATED;
 767             break;
 768         case OC_STACK_RESOURCE_DELETED:
 769             ret = CA_DELETED;
 770             break;
 771         case OC_STACK_RESOURCE_CHANGED:
 772             ret = CA_CHANGED;
 773             break;
 774         case OC_STACK_INVALID_QUERY:
 775             ret = CA_BAD_REQ;
 776             break;
 777         case OC_STACK_INVALID_OPTION:
 778             ret = CA_BAD_OPT;
 779             break;
 780         case OC_STACK_NO_RESOURCE:
 781             ret = CA_NOT_FOUND;
 782             break;
 783         case OC_STACK_COMM_ERROR:
 784             ret = CA_RETRANSMIT_TIMEOUT;
 785             break;
 786         case OC_STACK_UNAUTHORIZED_REQ:
 787             ret = CA_UNAUTHORIZED_REQ;
 788             break;
 789         default:
 790             break;
 791     }
 792     return ret;
 793 }
 794
 795 CATransportFlags_t OCToCATransportFlags(OCTransportFlags ocFlags)
 796 {
 797     CATransportFlags_t caFlags = (CATransportFlags_t)ocFlags;
 798
 799     // supply default behavior.
 800     if ((caFlags & (CA_IPV6|CA_IPV4)) == 0)
 801     {
 802         caFlags = (CATransportFlags_t)(caFlags|CA_IPV6|CA_IPV4);
 803     }
 804     if ((caFlags & OC_MASK_SCOPE) == 0)
 805     {
 806         caFlags = (CATransportFlags_t)(caFlags|OC_SCOPE_LINK);
 807     }
 808     return caFlags;
 809 }
 810
 811 OCTransportFlags CAToOCTransportFlags(CATransportFlags_t caFlags)
 812 {
 813     return (OCTransportFlags)caFlags;
 814 }
 815
 816 static OCStackResult ResetPresenceTTL(ClientCB *cbNode, uint32_t maxAgeSeconds)
 817 {
 818     uint32_t lowerBound  = 0;
 819     uint32_t higherBound = 0;
 820
 821     if (!cbNode || !cbNode->presence || !cbNode->presence->timeOut)
 822     {
 823         return OC_STACK_INVALID_PARAM;
 824     }
 825
 826     OIC_LOG_V(INFO, TAG, "Update presence TTL, time is %u", GetTicks(0));
 827
 828     cbNode->presence->TTL = maxAgeSeconds;
 829
 830     for (int index = 0; index < PresenceTimeOutSize; index++)
 831     {
 832         // Guard against overflow
 833         if (cbNode->presence->TTL < (UINT32_MAX/(MILLISECONDS_PER_SECOND*PresenceTimeOut[index]))
 834                                      * 100)
 835         {
 836             lowerBound = GetTicks((PresenceTimeOut[index] *
 837                                   cbNode->presence->TTL *
 838                                   MILLISECONDS_PER_SECOND)/100);
 839         }
 840         else
 841         {
 842             lowerBound = GetTicks(UINT32_MAX);
 843         }
 844
 845         if (cbNode->presence->TTL < (UINT32_MAX/(MILLISECONDS_PER_SECOND*PresenceTimeOut[index+1]))
 846                                      * 100)
 847         {
 848             higherBound = GetTicks((PresenceTimeOut[index + 1] *
 849                                    cbNode->presence->TTL *
 850                                    MILLISECONDS_PER_SECOND)/100);
 851         }
 852         else
 853         {
 854             higherBound = GetTicks(UINT32_MAX);
 855         }
 856
 857         cbNode->presence->timeOut[index] = OCGetRandomRange(lowerBound, higherBound);
 858
 859         OIC_LOG_V(DEBUG, TAG, "lowerBound timeout  %d", lowerBound);
 860         OIC_LOG_V(DEBUG, TAG, "higherBound timeout %d", higherBound);
 861         OIC_LOG_V(DEBUG, TAG, "timeOut entry  %d", cbNode->presence->timeOut[index]);
 862     }
 863
 864     cbNode->presence->TTLlevel = 0;
 865
 866     OIC_LOG_V(DEBUG, TAG, "this TTL level %d", cbNode->presence->TTLlevel);
 867     return OC_STACK_OK;
 868 }
 869
 870 const char *convertTriggerEnumToString(OCPresenceTrigger trigger)
 871 {
 872     if (trigger == OC_PRESENCE_TRIGGER_CREATE)
 873     {
 874         return OC_RSRVD_TRIGGER_CREATE;
 875     }
 876     else if (trigger == OC_PRESENCE_TRIGGER_CHANGE)
 877     {
 878         return OC_RSRVD_TRIGGER_CHANGE;
 879     }
 880     else
 881     {
 882         return OC_RSRVD_TRIGGER_DELETE;
 883     }
 884 }
 885
 886 OCPresenceTrigger convertTriggerStringToEnum(const char * triggerStr)
 887 {
 888     if(!triggerStr)
 889     {
 890         return OC_PRESENCE_TRIGGER_CREATE;
 891     }
 892     else if(strcmp(triggerStr, OC_RSRVD_TRIGGER_CREATE) == 0)
 893     {
 894         return OC_PRESENCE_TRIGGER_CREATE;
 895     }
 896     else if(strcmp(triggerStr, OC_RSRVD_TRIGGER_CHANGE) == 0)
 897     {
 898         return OC_PRESENCE_TRIGGER_CHANGE;
 899     }
 900     else
 901     {
 902         return OC_PRESENCE_TRIGGER_DELETE;
 903     }
 904 }
 905
 906 /**
 907  * Encode an address string to match RFC 6874.
 908  *
 909  * @param outputAddress    a char array to be written with the encoded string.
 910  *
 911  * @param outputSize       size of outputAddress buffer.
 912  *
 913  * @param inputAddress     a char array of size <= CA_MAX_URI_LENGTH
 914  *                         containing a valid IPv6 address string.
 915  *
 916  * @return                 OC_STACK_OK if encoding succeeded.
 917  *                         Else an error occured.
 918  */
 919  OCStackResult encodeAddressForRFC6874(char *outputAddress,
 920                                        size_t outputSize,
 921                                        const char *inputAddress)
 922 {
 923     VERIFY_NON_NULL(inputAddress,  FATAL, OC_STACK_INVALID_PARAM);
 924     VERIFY_NON_NULL(outputAddress, FATAL, OC_STACK_INVALID_PARAM);
 925
 926     size_t inputLength = strnlen(inputAddress, outputSize);
 927
 928     // inputSize includes the null terminator
 929     size_t inputSize = inputLength + 1;
 930
 931     if (inputSize > outputSize)
 932     {
 933         OIC_LOG_V(ERROR, TAG,
 934                   "encodeAddressForRFC6874 failed: "
 935                   "outputSize (%zu) < inputSize (%zu)",
 936                   outputSize, inputSize);
 937
 938         return OC_STACK_ERROR;
 939     }
 940
 941     char* percentChar = strchr(inputAddress, '%');
 942
 943     // If there is no '%' character, then no change is required to the string.
 944     if (NULL == percentChar)
 945     {
 946         OICStrcpy(outputAddress, outputSize, inputAddress);
 947         return OC_STACK_OK;
 948     }
 949
 950     const char* addressPart = &inputAddress[0];
 951     const char* scopeIdPart = percentChar + 1;
 952
 953     // Sanity check to make sure this string doesn't have more '%' characters
 954     if (NULL != strchr(scopeIdPart, '%'))
 955     {
 956         return OC_STACK_ERROR;
 957     }
 958
 959     // If no string follows the first '%', then the input was invalid.
 960     if (scopeIdPart[0] == '\0')
 961     {
 962         OIC_LOG(ERROR, TAG, "encodeAddressForRFC6874 failed: Invalid input string: no scope ID!");
 963         return OC_STACK_ERROR;
 964     }
 965
 966     // Check to see if the string is already encoded
 967     if ((scopeIdPart[0] == '2') && (scopeIdPart[1] == '5'))
 968     {
 969         OIC_LOG(ERROR, TAG, "encodeAddressForRFC6874 failed: Input string is already encoded");
 970         return OC_STACK_ERROR;
 971     }
 972
 973     // Fail if we don't have room for encoded string's two additional chars
 974     if (outputSize < (inputSize + 2))
 975     {
 976         OIC_LOG(ERROR, TAG, "encodeAddressForRFC6874 failed: encoded output will not fit!");
 977         return OC_STACK_ERROR;
 978     }
 979
 980     // Restore the null terminator with an escaped '%' character, per RFC 6874
 981     OICStrcpy(outputAddress, scopeIdPart - addressPart, addressPart);
 982     strcat(outputAddress, "%25");
 983     strcat(outputAddress, scopeIdPart);
 984
 985     return OC_STACK_OK;
 986 }
 987
 988 /**
 989  * The cononical presence allows constructed URIs to be string compared.
 990  *
 991  * requestUri must be a char array of size CA_MAX_URI_LENGTH
 992  */
 993 static int FormCanonicalPresenceUri(const CAEndpoint_t *endpoint, char *resourceUri,
 994                                     char *presenceUri, bool isMulticast)
 995 {
 996     VERIFY_NON_NULL(endpoint   , FATAL, OC_STACK_INVALID_PARAM);
 997     VERIFY_NON_NULL(resourceUri, FATAL, OC_STACK_INVALID_PARAM);
 998     VERIFY_NON_NULL(presenceUri, FATAL, OC_STACK_INVALID_PARAM);
 999
1000     if (isMulticast)
1001     {
1002         OIC_LOG(DEBUG, TAG, "Make Multicast Presence URI");
1003         return snprintf(presenceUri, CA_MAX_URI_LENGTH, "%s", OC_RSRVD_PRESENCE_URI);
1004     }
1005
1006     CAEndpoint_t *ep = (CAEndpoint_t *)endpoint;
1007     if (ep->adapter == CA_ADAPTER_IP)
1008     {
1009         if ((ep->flags & CA_IPV6) && !(ep->flags & CA_IPV4))
1010         {
1011             if ('\0' == ep->addr[0])  // multicast
1012             {
1013                 return snprintf(presenceUri, CA_MAX_URI_LENGTH, OC_RSRVD_PRESENCE_URI);
1014             }
1015             else
1016             {
1017                 char addressEncoded[CA_MAX_URI_LENGTH] = {0};
1018
1019                 OCStackResult result = encodeAddressForRFC6874(addressEncoded,
1020                                                                sizeof(addressEncoded),
1021                                                                ep->addr);
1022
1023                 if (OC_STACK_OK != result)
1024                 {
1025                     return -1;
1026                 }
1027
1028                 return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://[%s]:%u%s",
1029                         addressEncoded, ep->port, OC_RSRVD_PRESENCE_URI);
1030             }
1031         }
1032         else
1033         {
1034             if ('\0' == ep->addr[0])  // multicast
1035             {
1036                 OICStrcpy(ep->addr, sizeof(ep->addr), OC_MULTICAST_IP);
1037                 ep->port = OC_MULTICAST_PORT;
1038             }
1039             return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://%s:%u%s",
1040                     ep->addr, ep->port, OC_RSRVD_PRESENCE_URI);
1041         }
1042     }
1043
1044     // might work for other adapters (untested, but better than nothing)
1045     return snprintf(presenceUri, CA_MAX_URI_LENGTH, "coap://%s%s", ep->addr,
1046                     OC_RSRVD_PRESENCE_URI);
1047 }
1048
1049
1050 OCStackResult HandlePresenceResponse(const CAEndpoint_t *endpoint,
1051                             const CAResponseInfo_t *responseInfo)
1052 {
1053     VERIFY_NON_NULL(endpoint, FATAL, OC_STACK_INVALID_PARAM);
1054     VERIFY_NON_NULL(responseInfo, FATAL, OC_STACK_INVALID_PARAM);
1055
1056     OCStackApplicationResult cbResult = OC_STACK_DELETE_TRANSACTION;
1057     ClientCB * cbNode = NULL;
1058     char *resourceTypeName = NULL;
1059     OCClientResponse response = {.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
1060     OCStackResult result = OC_STACK_ERROR;
1061     uint32_t maxAge = 0;
1062     int uriLen;
1063     char presenceUri[CA_MAX_URI_LENGTH];
1064
1065     int presenceSubscribe = 0;
1066     int multicastPresenceSubscribe = 0;
1067
1068     if (responseInfo->result != CA_CONTENT)
1069     {
1070         OIC_LOG_V(ERROR, TAG, "HandlePresenceResponse failed %d", responseInfo->result);
1071         return OC_STACK_ERROR;
1072     }
1073
1074     response.payload = NULL;
1075     response.result = OC_STACK_OK;
1076
1077     CopyEndpointToDevAddr(endpoint, &response.devAddr);
1078     FixUpClientResponse(&response);
1079
1080     if (responseInfo->info.payload)
1081     {
1082         result = OCParsePayload(&response.payload,
1083                 PAYLOAD_TYPE_PRESENCE,
1084                 responseInfo->info.payload,
1085                 responseInfo->info.payloadSize);
1086
1087         if(result != OC_STACK_OK)
1088         {
1089             OIC_LOG(ERROR, TAG, "Presence parse failed");
1090             goto exit;
1091         }
1092         if(!response.payload || response.payload->type != PAYLOAD_TYPE_PRESENCE)
1093         {
1094             OIC_LOG(ERROR, TAG, "Presence payload was wrong type");
1095             result = OC_STACK_ERROR;
1096             goto exit;
1097         }
1098         response.sequenceNumber = ((OCPresencePayload*)response.payload)->sequenceNumber;
1099         resourceTypeName = ((OCPresencePayload*)response.payload)->resourceType;
1100         maxAge = ((OCPresencePayload*)response.payload)->maxAge;
1101     }
1102
1103     // check for unicast presence
1104     uriLen = FormCanonicalPresenceUri(endpoint, OC_RSRVD_PRESENCE_URI, presenceUri,
1105                                       responseInfo->isMulticast);
1106     if (uriLen < 0 || (size_t)uriLen >= sizeof (presenceUri))
1107     {
1108         return OC_STACK_INVALID_URI;
1109     }
1110     OIC_LOG(ERROR, TAG, "check for unicast presence");
1111     cbNode = GetClientCB(NULL, 0, NULL, presenceUri);
1112     if (cbNode)
1113     {
1114         presenceSubscribe = 1;
1115     }
1116     else
1117     {
1118         // check for multicast presence
1119         OIC_LOG(ERROR, TAG, "check for multicast presence");
1120         cbNode = GetClientCB(NULL, 0, NULL, OC_RSRVD_PRESENCE_URI);
1121         if (cbNode)
1122         {
1123             multicastPresenceSubscribe = 1;
1124         }
1125     }
1126
1127     if (!presenceSubscribe && !multicastPresenceSubscribe)
1128     {
1129         OIC_LOG(ERROR, TAG, "Received a presence notification, but no callback, ignoring");
1130         goto exit;
1131     }
1132
1133     if (presenceSubscribe)
1134     {
1135         if(cbNode->sequenceNumber == response.sequenceNumber)
1136         {
1137             OIC_LOG(INFO, TAG, "No presence change");
1138             ResetPresenceTTL(cbNode, maxAge);
1139             OIC_LOG_V(INFO, TAG, "ResetPresenceTTL - TTLlevel:%d\n", cbNode->presence->TTLlevel);
1140             goto exit;
1141         }
1142
1143         if(maxAge == 0)
1144         {
1145             OIC_LOG(INFO, TAG, "Stopping presence");
1146             response.result = OC_STACK_PRESENCE_STOPPED;
1147             if(cbNode->presence)
1148             {
1149                 OICFree(cbNode->presence->timeOut);
1150                 OICFree(cbNode->presence);
1151                 cbNode->presence = NULL;
1152             }
1153         }
1154         else
1155         {
1156             if(!cbNode->presence)
1157             {
1158                 cbNode->presence = (OCPresence *)OICMalloc(sizeof (OCPresence));
1159
1160                 if(!(cbNode->presence))
1161                 {
1162                     OIC_LOG(ERROR, TAG, "Could not allocate memory for cbNode->presence");
1163                     result = OC_STACK_NO_MEMORY;
1164                     goto exit;
1165                 }
1166
1167                 VERIFY_NON_NULL_V(cbNode->presence);
1168                 cbNode->presence->timeOut = NULL;
1169                 cbNode->presence->timeOut = (uint32_t *)
1170                         OICMalloc(PresenceTimeOutSize * sizeof(uint32_t));
1171                 if(!(cbNode->presence->timeOut)){
1172                     OIC_LOG(ERROR, TAG,
1173                                   "Could not allocate memory for cbNode->presence->timeOut");
1174                     OICFree(cbNode->presence);
1175                     result = OC_STACK_NO_MEMORY;
1176                     goto exit;
1177                 }
1178             }
1179
1180             ResetPresenceTTL(cbNode, maxAge);
1181
1182             cbNode->sequenceNumber = response.sequenceNumber;
1183
1184             // Ensure that a filter is actually applied.
1185             if( resourceTypeName && cbNode->filterResourceType)
1186             {
1187                 if(!findResourceType(cbNode->filterResourceType, resourceTypeName))
1188                 {
1189                     goto exit;
1190                 }
1191             }
1192         }
1193     }
1194     else
1195     {
1196         // This is the multicast case
1197         OCMulticastNode* mcNode = NULL;
1198         mcNode = GetMCPresenceNode(presenceUri);
1199
1200         if(mcNode != NULL)
1201         {
1202             if(mcNode->nonce == response.sequenceNumber)
1203             {
1204                 OIC_LOG(INFO, TAG, "No presence change (Multicast)");
1205                 goto exit;
1206             }
1207             mcNode->nonce = response.sequenceNumber;
1208
1209             if(maxAge == 0)
1210             {
1211                 OIC_LOG(INFO, TAG, "Stopping presence");
1212                 response.result = OC_STACK_PRESENCE_STOPPED;
1213             }
1214         }
1215         else
1216         {
1217             char* uri = OICStrdup(presenceUri);
1218             if (!uri)
1219             {
1220                 OIC_LOG(INFO, TAG,
1221                     "No Memory for URI to store in the presence node");
1222                 result = OC_STACK_NO_MEMORY;
1223                 goto exit;
1224             }
1225
1226             result = AddMCPresenceNode(&mcNode, uri, response.sequenceNumber);
1227             if(result == OC_STACK_NO_MEMORY)
1228             {
1229                 OIC_LOG(INFO, TAG,
1230                     "No Memory for Multicast Presence Node");
1231                 OICFree(uri);
1232                 goto exit;
1233             }
1234             // presence node now owns uri
1235         }
1236
1237
1238
1239         // Ensure that a filter is actually applied.
1240         if(resourceTypeName && cbNode->filterResourceType)
1241         {
1242             OIC_LOG_V(INFO, TAG, "find resource type : %s", resourceTypeName);
1243             if(!findResourceType(cbNode->filterResourceType, resourceTypeName))
1244             {
1245                 goto exit;
1246             }
1247         }
1248     }
1249     OIC_LOG(INFO, TAG, "Callback for presence");
1250
1251     cbResult = cbNode->callBack(cbNode->context, cbNode->handle, &response);
1252
1253     if (cbResult == OC_STACK_DELETE_TRANSACTION)
1254     {
1255         FindAndDeleteClientCB(cbNode);
1256     }
1257
1258 exit:
1259     OCPayloadDestroy(response.payload);
1260     return result;
1261 }
1262
1263 void OCHandleResponse(const CAEndpoint_t* endPoint, const CAResponseInfo_t* responseInfo)
1264 {
1265     OIC_LOG(DEBUG, TAG, "Enter OCHandleResponse");
1266
1267     if(responseInfo->info.resourceUri &&
1268         strcmp(responseInfo->info.resourceUri, OC_RSRVD_PRESENCE_URI) == 0)
1269     {
1270         HandlePresenceResponse(endPoint, responseInfo);
1271         return;
1272     }
1273
1274     ClientCB *cbNode = GetClientCB(responseInfo->info.token,
1275             responseInfo->info.tokenLength, NULL, NULL);
1276
1277     ResourceObserver * observer = GetObserverUsingToken (responseInfo->info.token,
1278             responseInfo->info.tokenLength);
1279
1280     if(cbNode)
1281     {
1282         OIC_LOG(INFO, TAG, "There is a cbNode associated with the response token");
1283         if(responseInfo->result == CA_EMPTY)
1284         {
1285             OIC_LOG(INFO, TAG, "Receiving A ACK/RESET for this token");
1286             // We do not have a case for the client to receive a RESET
1287             if(responseInfo->info.type == CA_MSG_ACKNOWLEDGE)
1288             {
1289                 //This is the case of receiving an ACK on a request to a slow resource!
1290                 OIC_LOG(INFO, TAG, "This is a pure ACK");
1291                 //TODO: should we inform the client
1292                 //      app that at least the request was received at the server?
1293             }
1294         }
1295         else if(responseInfo->result == CA_RETRANSMIT_TIMEOUT)
1296         {
1297             OIC_LOG(INFO, TAG, "Receiving A Timeout for this token");
1298             OIC_LOG(INFO, TAG, "Calling into application address space");
1299
1300             OCClientResponse response =
1301                 {.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
1302             CopyEndpointToDevAddr(endPoint, &response.devAddr);
1303             FixUpClientResponse(&response);
1304             response.resourceUri = responseInfo->info.resourceUri;
1305             memcpy(response.identity.id, responseInfo->info.identity.id,
1306                                                 sizeof (response.identity.id));
1307             response.identity.id_length = responseInfo->info.identity.id_length;
1308
1309             response.result = CAResponseToOCStackResult(responseInfo->result);
1310             cbNode->callBack(cbNode->context,
1311                     cbNode->handle, &response);
1312             FindAndDeleteClientCB(cbNode);
1313         }
1314         else
1315         {
1316             OIC_LOG(INFO, TAG, "This is a regular response, A client call back is found");
1317             OIC_LOG(INFO, TAG, "Calling into application address space");
1318
1319             OCClientResponse response =
1320                 {.devAddr = {.adapter = OC_DEFAULT_ADAPTER}};
1321             response.sequenceNumber = MAX_SEQUENCE_NUMBER + 1;
1322             CopyEndpointToDevAddr(endPoint, &response.devAddr);
1323             FixUpClientResponse(&response);
1324             response.resourceUri = responseInfo->info.resourceUri;
1325             memcpy(response.identity.id, responseInfo->info.identity.id,
1326                                                 sizeof (response.identity.id));
1327             response.identity.id_length = responseInfo->info.identity.id_length;
1328
1329             response.result = CAResponseToOCStackResult(responseInfo->result);
1330
1331             if(responseInfo->info.payload &&
1332                responseInfo->info.payloadSize)
1333             {
1334                 OCPayloadType type = PAYLOAD_TYPE_INVALID;
1335                 // check the security resource
1336                 if (SRMIsSecurityResourceURI(cbNode->requestUri))
1337                 {
1338                     type = PAYLOAD_TYPE_SECURITY;
1339                 }
1340                 else if (cbNode->method == OC_REST_DISCOVER)
1341                 {
1342                     if (strncmp(OC_RSRVD_WELL_KNOWN_URI,cbNode->requestUri,
1343                                 sizeof(OC_RSRVD_WELL_KNOWN_URI) - 1) == 0)
1344                     {
1345                         type = PAYLOAD_TYPE_DISCOVERY;
1346                     }
1347 #ifdef WITH_MQ
1348                     else if (strcmp(cbNode->requestUri, OC_RSRVD_WELL_KNOWN_MQ_URI) == 0)
1349                     {
1350                         type = PAYLOAD_TYPE_DISCOVERY;
1351                     }
1352 #endif
1353                     else if (strcmp(cbNode->requestUri, OC_RSRVD_DEVICE_URI) == 0)
1354                     {
1355                         type = PAYLOAD_TYPE_DEVICE;
1356                     }
1357                     else if (strcmp(cbNode->requestUri, OC_RSRVD_PLATFORM_URI) == 0)
1358                     {
1359                         type = PAYLOAD_TYPE_PLATFORM;
1360                     }
1361 #ifdef ROUTING_GATEWAY
1362                     else if (strcmp(cbNode->requestUri, OC_RSRVD_GATEWAY_URI) == 0)
1363                     {
1364                         type = PAYLOAD_TYPE_REPRESENTATION;
1365                     }
1366 #endif
1367                     else if (strcmp(cbNode->requestUri, OC_RSRVD_RD_URI) == 0)
1368                     {
1369                         type = PAYLOAD_TYPE_REPRESENTATION ;
1370                     }
1371 #ifdef TCP_ADAPTER
1372                     else if (strcmp(cbNode->requestUri, KEEPALIVE_RESOURCE_URI) == 0)
1373                     {
1374                         type = PAYLOAD_TYPE_REPRESENTATION;
1375                     }
1376 #endif
1377                     else
1378                     {
1379                         OIC_LOG_V(ERROR, TAG, "Unknown Payload type in Discovery: %d %s",
1380                                 cbNode->method, cbNode->requestUri);
1381                         return;
1382                     }
1383                 }
1384                 else if (cbNode->method == OC_REST_GET ||
1385                          cbNode->method == OC_REST_PUT ||
1386                          cbNode->method == OC_REST_POST ||
1387                          cbNode->method == OC_REST_OBSERVE ||
1388                          cbNode->method == OC_REST_OBSERVE_ALL ||
1389                          cbNode->method == OC_REST_DELETE)
1390                 {
1391                     if (cbNode->requestUri)
1392                     {
1393                         if (strcmp(OC_RSRVD_PLATFORM_URI, cbNode->requestUri) == 0)
1394                         {
1395                             type = PAYLOAD_TYPE_PLATFORM;
1396                         }
1397                         else if (strcmp(OC_RSRVD_DEVICE_URI, cbNode->requestUri) == 0)
1398                         {
1399                             type = PAYLOAD_TYPE_DEVICE;
1400                         }
1401                         if (type == PAYLOAD_TYPE_INVALID)
1402                         {
1403                             OIC_LOG_V(INFO, TAG, "Assuming PAYLOAD_TYPE_REPRESENTATION: %d %s",
1404                                     cbNode->method, cbNode->requestUri);
1405                             type = PAYLOAD_TYPE_REPRESENTATION;
1406                         }
1407                     }
1408                     else
1409                     {
1410                         OIC_LOG(INFO, TAG, "No Request URI, PROXY URI");
1411                         type = PAYLOAD_TYPE_REPRESENTATION;
1412                     }
1413                 }
1414                 else
1415                 {
1416                     OIC_LOG_V(ERROR, TAG, "Unknown Payload type: %d %s",
1417                             cbNode->method, cbNode->requestUri);
1418                     return;
1419                 }
1420
1421                 if(OC_STACK_OK != OCParsePayload(&response.payload,
1422                             type,
1423                             responseInfo->info.payload,
1424                             responseInfo->info.payloadSize))
1425                 {
1426                     OIC_LOG(ERROR, TAG, "Error converting payload");
1427                     OCPayloadDestroy(response.payload);
1428                     return;
1429                 }
1430             }
1431
1432             response.numRcvdVendorSpecificHeaderOptions = 0;
1433             if(responseInfo->info.numOptions > 0)
1434             {
1435                 int start = 0;
1436                 //First option always with option ID is COAP_OPTION_OBSERVE if it is available.
1437                 if(responseInfo->info.options[0].optionID == COAP_OPTION_OBSERVE)
1438                 {
1439                     size_t i;
1440                     uint32_t observationOption;
1441                     uint8_t* optionData = (uint8_t*)responseInfo->info.options[0].optionData;
1442                     for (observationOption=0, i=0;
1443                             i<sizeof(uint32_t) && i<responseInfo->info.options[0].optionLength;
1444                             i++)
1445                     {
1446                         observationOption =
1447                             (observationOption << 8) | optionData[i];
1448                     }
1449                     response.sequenceNumber = observationOption;
1450                     response.numRcvdVendorSpecificHeaderOptions = responseInfo->info.numOptions - 1;
1451                     start = 1;
1452                 }
1453                 else
1454                 {
1455                     response.numRcvdVendorSpecificHeaderOptions = responseInfo->info.numOptions;
1456                 }
1457
1458                 if(response.numRcvdVendorSpecificHeaderOptions > MAX_HEADER_OPTIONS)
1459                 {
1460                     OIC_LOG(ERROR, TAG, "#header options are more than MAX_HEADER_OPTIONS");
1461                     OCPayloadDestroy(response.payload);
1462                     return;
1463                 }
1464
1465                 for (uint8_t i = start; i < responseInfo->info.numOptions; i++)
1466                 {
1467                     memcpy (&(response.rcvdVendorSpecificHeaderOptions[i-start]),
1468                             &(responseInfo->info.options[i]), sizeof(OCHeaderOption));
1469                 }
1470             }
1471
1472             if (cbNode->method == OC_REST_OBSERVE &&
1473                 response.sequenceNumber > OC_OFFSET_SEQUENCE_NUMBER &&
1474                 cbNode->sequenceNumber <=  MAX_SEQUENCE_NUMBER &&
1475                 response.sequenceNumber <= cbNode->sequenceNumber)
1476             {
1477                 OIC_LOG_V(INFO, TAG, "Received stale notification. Number :%d",
1478                                                  response.sequenceNumber);
1479             }
1480             else
1481             {
1482                 OCStackApplicationResult appFeedback = cbNode->callBack(cbNode->context,
1483                                                                         cbNode->handle,
1484                                                                         &response);
1485                 cbNode->sequenceNumber = response.sequenceNumber;
1486
1487                 if (appFeedback == OC_STACK_DELETE_TRANSACTION)
1488                 {
1489                     FindAndDeleteClientCB(cbNode);
1490                 }
1491                 else
1492                 {
1493                     // To keep discovery callbacks active.
1494                     cbNode->TTL = GetTicks(MAX_CB_TIMEOUT_SECONDS *
1495                                             MILLISECONDS_PER_SECOND);
1496                 }
1497             }
1498
1499             //Need to send ACK when the response is CON
1500             if(responseInfo->info.type == CA_MSG_CONFIRM)
1501             {
1502                 SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
1503                         CA_MSG_ACKNOWLEDGE, 0, NULL, NULL, 0, NULL, CA_RESPONSE_FOR_RES);
1504             }
1505
1506             OCPayloadDestroy(response.payload);
1507         }
1508         return;
1509     }
1510
1511     if(observer)
1512     {
1513         OIC_LOG(INFO, TAG, "There is an observer associated with the response token");
1514         if(responseInfo->result == CA_EMPTY)
1515         {
1516             OIC_LOG(INFO, TAG, "Receiving A ACK/RESET for this token");
1517             if(responseInfo->info.type == CA_MSG_RESET)
1518             {
1519                 OIC_LOG(INFO, TAG, "This is a RESET");
1520                 OCStackFeedBack(responseInfo->info.token, responseInfo->info.tokenLength,
1521                         OC_OBSERVER_NOT_INTERESTED);
1522             }
1523             else if(responseInfo->info.type == CA_MSG_ACKNOWLEDGE)
1524             {
1525                 OIC_LOG(INFO, TAG, "This is a pure ACK");
1526                 OCStackFeedBack(responseInfo->info.token, responseInfo->info.tokenLength,
1527                         OC_OBSERVER_STILL_INTERESTED);
1528             }
1529         }
1530         else if(responseInfo->result == CA_RETRANSMIT_TIMEOUT)
1531         {
1532             OIC_LOG(INFO, TAG, "Receiving Time Out for an observer");
1533             OCStackFeedBack(responseInfo->info.token, responseInfo->info.tokenLength,
1534                     OC_OBSERVER_FAILED_COMM);
1535         }
1536         return;
1537     }
1538
1539     if(!cbNode && !observer)
1540     {
1541         if(myStackMode == OC_CLIENT || myStackMode == OC_CLIENT_SERVER
1542            || myStackMode == OC_GATEWAY)
1543         {
1544             OIC_LOG(INFO, TAG, "This is a client, but no cbNode was found for token");
1545             if(responseInfo->result == CA_EMPTY)
1546             {
1547                 OIC_LOG(INFO, TAG, "Receiving CA_EMPTY in the ocstack");
1548             }
1549             else
1550             {
1551                 OIC_LOG(INFO, TAG, "Received a message without callbacks. Sending RESET");
1552                 SendDirectStackResponse(endPoint, responseInfo->info.messageId, CA_EMPTY,
1553                                         CA_MSG_RESET, 0, NULL, NULL, 0, NULL, CA_RESPONSE_FOR_RES);
1554             }
1555         }
1556
1557         if(myStackMode == OC_SERVER || myStackMode == OC_CLIENT_SERVER
1558            || myStackMode == OC_GATEWAY)
1559         {
1560             OIC_LOG(INFO, TAG, "This is a server, but no observer was found for token");
1561             if (responseInfo->info.type == CA_MSG_ACKNOWLEDGE)
1562             {
1563                 OIC_LOG_V(INFO, TAG, "Received ACK at server for messageId : %d",
1564                                             responseInfo->info.messageId);
1565             }
1566             if (responseInfo->info.type == CA_MSG_RESET)
1567             {
1568                 OIC_LOG_V(INFO, TAG, "Received RESET at server for messageId : %d",
1569                                             responseInfo->info.messageId);
1570             }
1571         }
1572
1573         return;
1574     }
1575 }
1576
1577 void HandleCAResponses(const CAEndpoint_t* endPoint, const CAResponseInfo_t* responseInfo)
1578 {
1579     VERIFY_NON_NULL_NR(endPoint, FATAL);
1580     VERIFY_NON_NULL_NR(responseInfo, FATAL);
1581
1582     OIC_LOG(INFO, TAG, "Enter HandleCAResponses");
1583
1584 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
1585 #ifdef ROUTING_GATEWAY
1586     bool needRIHandling = false;
1587     /*
1588      * Routing manager is going to update either of endpoint or response or both.
1589      * This typecasting is done to avoid unnecessary duplication of Endpoint and responseInfo
1590      * RM can update "routeData" option in endPoint so that future RI requests can be sent to proper
1591      * destination.
1592      */
1593     OCStackResult ret = RMHandleResponse((CAResponseInfo_t *)responseInfo, (CAEndpoint_t *)endPoint,
1594                                          &needRIHandling);
1595     if(ret != OC_STACK_OK || !needRIHandling)
1596     {
1597         OIC_LOG_V(INFO, TAG, "Routing status![%d]. Not forwarding to RI", ret);
1598         return;
1599     }
1600 #endif
1601
1602     /*
1603      * Put source in sender endpoint so that the next packet from application can be routed to
1604      * proper destination and remove "RM" coap header option before passing request / response to
1605      * RI as this option will make no sense to either RI or application.
1606      */
1607     RMUpdateInfo((CAHeaderOption_t **) &(responseInfo->info.options),
1608                  (uint8_t *) &(responseInfo->info.numOptions),
1609                  (CAEndpoint_t *) endPoint);
1610 #endif
1611
1612     OCHandleResponse(endPoint, responseInfo);
1613
1614     OIC_LOG(INFO, TAG, "Exit HandleCAResponses");
1615 }
1616
1617 /*
1618  * This function handles error response from CA
1619  * code shall be added to handle the errors
1620  */
1621 void HandleCAErrorResponse(const CAEndpoint_t *endPoint, const CAErrorInfo_t *errorInfo)
1622 {
1623     OIC_LOG(INFO, TAG, "Enter HandleCAErrorResponse");
1624
1625     if (NULL == endPoint)
1626     {
1627         OIC_LOG(ERROR, TAG, "endPoint is NULL");
1628         return;
1629     }
1630
1631     if (NULL == errorInfo)
1632     {
1633         OIC_LOG(ERROR, TAG, "errorInfo is NULL");
1634         return;
1635     }
1636
1637     ClientCB *cbNode = GetClientCB(errorInfo->info.token,
1638                                    errorInfo->info.tokenLength, NULL, NULL);
1639     if (cbNode)
1640     {
1641         OCClientResponse response = { .devAddr = { .adapter = OC_DEFAULT_ADAPTER } };
1642         CopyEndpointToDevAddr(endPoint, &response.devAddr);
1643         FixUpClientResponse(&response);
1644         response.resourceUri = errorInfo->info.resourceUri;
1645         memcpy(response.identity.id, errorInfo->info.identity.id,
1646                sizeof (response.identity.id));
1647         response.identity.id_length = errorInfo->info.identity.id_length;
1648         response.result = CAResultToOCStackResult(errorInfo->result);
1649
1650         cbNode->callBack(cbNode->context, cbNode->handle, &response);
1651     }
1652
1653     OIC_LOG(INFO, TAG, "Exit HandleCAErrorResponse");
1654 }
1655
1656 /*
1657  * This function sends out Direct Stack Responses. These are responses that are not coming
1658  * from the application entity handler. These responses have no payload and are usually ACKs,
1659  * RESETs or some error conditions that were caught by the stack.
1660  */
1661 OCStackResult SendDirectStackResponse(const CAEndpoint_t* endPoint, const uint16_t coapID,
1662         const CAResponseResult_t responseResult, const CAMessageType_t type,
1663         const uint8_t numOptions, const CAHeaderOption_t *options,
1664         CAToken_t token, uint8_t tokenLength, const char *resourceUri,
1665         CADataType_t dataType)
1666 {
1667     OIC_LOG(DEBUG, TAG, "Entering SendDirectStackResponse");
1668     CAResponseInfo_t respInfo = {
1669         .result = responseResult
1670     };
1671     respInfo.info.messageId = coapID;
1672     respInfo.info.numOptions = numOptions;
1673
1674     if (respInfo.info.numOptions)
1675     {
1676         respInfo.info.options =
1677             (CAHeaderOption_t *)OICCalloc(respInfo.info.numOptions, sizeof(CAHeaderOption_t));
1678         memcpy (respInfo.info.options, options,
1679                 sizeof(CAHeaderOption_t) * respInfo.info.numOptions);
1680
1681     }
1682
1683     respInfo.info.payload = NULL;
1684     respInfo.info.token = token;
1685     respInfo.info.tokenLength = tokenLength;
1686     respInfo.info.type = type;
1687     respInfo.info.resourceUri = OICStrdup (resourceUri);
1688     respInfo.info.acceptFormat = CA_FORMAT_UNDEFINED;
1689     respInfo.info.dataType = dataType;
1690
1691 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
1692     // Add the destination to route option from the endpoint->routeData.
1693     bool doPost = false;
1694     OCStackResult result = RMAddInfo(endPoint->routeData, &respInfo, false, &doPost);
1695     if(OC_STACK_OK != result)
1696     {
1697         OIC_LOG_V(ERROR, TAG, "Add routing option failed [%d]", result);
1698         return result;
1699     }
1700     if (doPost)
1701     {
1702         OIC_LOG(DEBUG, TAG, "Sending a POST message for EMPTY ACK in Client Mode");
1703         CARequestInfo_t reqInfo = {.method = CA_POST };
1704         /* The following initialization is not done in a single initializer block as in
1705          * arduino, .c file is compiled as .cpp and moves it from C99 to C++11.  The latter
1706          * does not have designated initalizers. This is a work-around for now.
1707          */
1708         reqInfo.info.type = CA_MSG_NONCONFIRM;
1709         reqInfo.info.messageId = coapID;
1710         reqInfo.info.tokenLength = tokenLength;
1711         reqInfo.info.token = token;
1712         reqInfo.info.numOptions = respInfo.info.numOptions;
1713         reqInfo.info.payload = NULL;
1714         reqInfo.info.resourceUri = OICStrdup (OC_RSRVD_GATEWAY_URI);
1715         if (reqInfo.info.numOptions)
1716         {
1717             reqInfo.info.options =
1718                 (CAHeaderOption_t *)OICCalloc(reqInfo.info.numOptions, sizeof(CAHeaderOption_t));
1719             if (NULL == reqInfo.info.options)
1720             {
1721                 OIC_LOG(ERROR, TAG, "Calloc failed");
1722                 return OC_STACK_NO_MEMORY;
1723             }
1724             memcpy (reqInfo.info.options, respInfo.info.options,
1725                     sizeof(CAHeaderOption_t) * reqInfo.info.numOptions);
1726
1727         }
1728         CAResult_t caResult = CASendRequest(endPoint, &reqInfo);
1729         OICFree (reqInfo.info.resourceUri);
1730         OICFree (reqInfo.info.options);
1731         OICFree (respInfo.info.resourceUri);
1732         OICFree (respInfo.info.options);
1733         if (CA_STATUS_OK != caResult)
1734         {
1735             OIC_LOG(ERROR, TAG, "CASendRequest error");
1736             return CAResultToOCResult(caResult);
1737         }
1738     }
1739     else
1740 #endif
1741     {
1742         CAResult_t caResult = CASendResponse(endPoint, &respInfo);
1743
1744         // resourceUri in the info field is cloned in the CA layer and
1745         // thus ownership is still here.
1746         OICFree (respInfo.info.resourceUri);
1747         OICFree (respInfo.info.options);
1748         if(CA_STATUS_OK != caResult)
1749         {
1750             OIC_LOG(ERROR, TAG, "CASendResponse error");
1751             return CAResultToOCResult(caResult);
1752         }
1753     }
1754     OIC_LOG(DEBUG, TAG, "Exit SendDirectStackResponse");
1755     return OC_STACK_OK;
1756 }
1757
1758 OCStackResult HandleStackRequests(OCServerProtocolRequest * protocolRequest)
1759 {
1760     OIC_LOG(INFO, TAG, "Entering HandleStackRequests (OCStack Layer)");
1761     OCStackResult result = OC_STACK_ERROR;
1762     if(!protocolRequest)
1763     {
1764         OIC_LOG(ERROR, TAG, "protocolRequest is NULL");
1765         return OC_STACK_INVALID_PARAM;
1766     }
1767
1768     OCServerRequest * request = GetServerRequestUsingToken(protocolRequest->requestToken,
1769             protocolRequest->tokenLength);
1770     if(!request)
1771     {
1772         OIC_LOG(INFO, TAG, "This is a new Server Request");
1773         result = AddServerRequest(&request, protocolRequest->coapID,
1774                 protocolRequest->delayedResNeeded, 0, protocolRequest->method,
1775                 protocolRequest->numRcvdVendorSpecificHeaderOptions,
1776                 protocolRequest->observationOption, protocolRequest->qos,
1777                 protocolRequest->query, protocolRequest->rcvdVendorSpecificHeaderOptions,
1778                 protocolRequest->payload, protocolRequest->requestToken,
1779                 protocolRequest->tokenLength, protocolRequest->resourceUrl,
1780                 protocolRequest->reqTotalSize, protocolRequest->acceptFormat,
1781                 &protocolRequest->devAddr);
1782         if (OC_STACK_OK != result)
1783         {
1784             OIC_LOG(ERROR, TAG, "Error adding server request");
1785             return result;
1786         }
1787
1788         if(!request)
1789         {
1790             OIC_LOG(ERROR, TAG, "Out of Memory");
1791             return OC_STACK_NO_MEMORY;
1792         }
1793
1794         if(!protocolRequest->reqMorePacket)
1795         {
1796             request->requestComplete = 1;
1797         }
1798     }
1799     else
1800     {
1801         OIC_LOG(INFO, TAG, "This is either a repeated or blocked Server Request");
1802     }
1803
1804     if(request->requestComplete)
1805     {
1806         OIC_LOG(INFO, TAG, "This Server Request is complete");
1807         ResourceHandling resHandling = OC_RESOURCE_VIRTUAL;
1808         OCResource *resource = NULL;
1809         result = DetermineResourceHandling (request, &resHandling, &resource);
1810         if (result == OC_STACK_OK)
1811         {
1812             result = ProcessRequest(resHandling, resource, request);
1813         }
1814     }
1815     else
1816     {
1817         OIC_LOG(INFO, TAG, "This Server Request is incomplete");
1818         result = OC_STACK_CONTINUE;
1819     }
1820     return result;
1821 }
1822
1823 void OCHandleRequests(const CAEndpoint_t* endPoint, const CARequestInfo_t* requestInfo)
1824 {
1825     OIC_LOG(DEBUG, TAG, "Enter OCHandleRequests");
1826
1827 #ifdef TCP_ADAPTER
1828     if (requestInfo->info.resourceUri &&
1829             strcmp(requestInfo->info.resourceUri, KEEPALIVE_RESOURCE_URI) == 0)
1830     {
1831         HandleKeepAliveRequest(endPoint, requestInfo);
1832         return;
1833     }
1834 #endif
1835
1836     OCStackResult requestResult = OC_STACK_ERROR;
1837
1838     if(myStackMode == OC_CLIENT)
1839     {
1840         //TODO: should the client be responding to requests?
1841         return;
1842     }
1843
1844     OCServerProtocolRequest serverRequest = {0};
1845
1846     OIC_LOG_V(INFO, TAG, "Endpoint URI : %s", requestInfo->info.resourceUri);
1847
1848     char * uriWithoutQuery = NULL;
1849     char * query  = NULL;
1850
1851     requestResult = getQueryFromUri(requestInfo->info.resourceUri, &query, &uriWithoutQuery);
1852
1853     if (requestResult != OC_STACK_OK || !uriWithoutQuery)
1854     {
1855         OIC_LOG_V(ERROR, TAG, "getQueryFromUri() failed with OC error code %d\n", requestResult);
1856         return;
1857     }
1858     OIC_LOG_V(INFO, TAG, "URI without query: %s", uriWithoutQuery);
1859     OIC_LOG_V(INFO, TAG, "Query : %s", query);
1860
1861     if(strlen(uriWithoutQuery) < MAX_URI_LENGTH)
1862     {
1863         OICStrcpy(serverRequest.resourceUrl, sizeof(serverRequest.resourceUrl), uriWithoutQuery);
1864         OICFree(uriWithoutQuery);
1865     }
1866     else
1867     {
1868         OIC_LOG(ERROR, TAG, "URI length exceeds MAX_URI_LENGTH.");
1869         OICFree(uriWithoutQuery);
1870         OICFree(query);
1871         return;
1872     }
1873
1874     if(query)
1875     {
1876         if(strlen(query) < MAX_QUERY_LENGTH)
1877         {
1878             OICStrcpy(serverRequest.query, sizeof(serverRequest.query), query);
1879             OICFree(query);
1880         }
1881         else
1882         {
1883             OIC_LOG(ERROR, TAG, "Query length exceeds MAX_QUERY_LENGTH.");
1884             OICFree(query);
1885             return;
1886         }
1887     }
1888
1889     if ((requestInfo->info.payload) && (0 < requestInfo->info.payloadSize))
1890     {
1891         serverRequest.reqTotalSize = requestInfo->info.payloadSize;
1892         serverRequest.payload = (uint8_t *) OICMalloc(requestInfo->info.payloadSize);
1893         if (!serverRequest.payload)
1894         {
1895             OIC_LOG(ERROR, TAG, "Allocation for payload failed.");
1896             return;
1897         }
1898         memcpy (serverRequest.payload, requestInfo->info.payload,
1899                 requestInfo->info.payloadSize);
1900     }
1901     else
1902     {
1903         serverRequest.reqTotalSize = 0;
1904     }
1905
1906     switch (requestInfo->method)
1907     {
1908         case CA_GET:
1909             serverRequest.method = OC_REST_GET;
1910             break;
1911         case CA_PUT:
1912             serverRequest.method = OC_REST_PUT;
1913             break;
1914         case CA_POST:
1915             serverRequest.method = OC_REST_POST;
1916             break;
1917         case CA_DELETE:
1918             serverRequest.method = OC_REST_DELETE;
1919             break;
1920         default:
1921             OIC_LOG_V(ERROR, TAG, "Received CA method %d not supported", requestInfo->method);
1922             SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_BAD_REQ,
1923                         requestInfo->info.type, requestInfo->info.numOptions,
1924                         requestInfo->info.options, requestInfo->info.token,
1925                         requestInfo->info.tokenLength, requestInfo->info.resourceUri,
1926                         CA_RESPONSE_DATA);
1927             OICFree(serverRequest.payload);
1928             return;
1929     }
1930
1931     OIC_LOG_BUFFER(INFO, TAG, (const uint8_t *)requestInfo->info.token,
1932             requestInfo->info.tokenLength);
1933
1934     serverRequest.tokenLength = requestInfo->info.tokenLength;
1935     if (serverRequest.tokenLength) {
1936         // Non empty token
1937         serverRequest.requestToken = (CAToken_t)OICMalloc(requestInfo->info.tokenLength);
1938
1939         if (!serverRequest.requestToken)
1940         {
1941             OIC_LOG(FATAL, TAG, "Allocation for token failed.");
1942             SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_INTERNAL_SERVER_ERROR,
1943                     requestInfo->info.type, requestInfo->info.numOptions,
1944                     requestInfo->info.options, requestInfo->info.token,
1945                     requestInfo->info.tokenLength, requestInfo->info.resourceUri,
1946                     CA_RESPONSE_DATA);
1947             OICFree(serverRequest.payload);
1948             return;
1949         }
1950         memcpy(serverRequest.requestToken, requestInfo->info.token, requestInfo->info.tokenLength);
1951     }
1952
1953     switch (requestInfo->info.acceptFormat)
1954     {
1955         case CA_FORMAT_APPLICATION_CBOR:
1956             serverRequest.acceptFormat = OC_FORMAT_CBOR;
1957             break;
1958         case CA_FORMAT_UNDEFINED:
1959             serverRequest.acceptFormat = OC_FORMAT_UNDEFINED;
1960             break;
1961         default:
1962             serverRequest.acceptFormat = OC_FORMAT_UNSUPPORTED;
1963     }
1964
1965     if (requestInfo->info.type == CA_MSG_CONFIRM)
1966     {
1967         serverRequest.qos = OC_HIGH_QOS;
1968     }
1969     else
1970     {
1971         serverRequest.qos = OC_LOW_QOS;
1972     }
1973     // CA does not need the following field
1974     // Are we sure CA does not need them? how is it responding to multicast
1975     serverRequest.delayedResNeeded = 0;
1976
1977     serverRequest.coapID = requestInfo->info.messageId;
1978
1979     CopyEndpointToDevAddr(endPoint, &serverRequest.devAddr);
1980
1981     // copy vendor specific header options
1982     uint8_t tempNum = (requestInfo->info.numOptions);
1983
1984     // Assume no observation requested and it is a pure GET.
1985     // If obs registration/de-registration requested it'll be fetched from the
1986     // options in GetObserveHeaderOption()
1987     serverRequest.observationOption = OC_OBSERVE_NO_OPTION;
1988
1989     GetObserveHeaderOption(&serverRequest.observationOption, requestInfo->info.options, &tempNum);
1990     if (requestInfo->info.numOptions > MAX_HEADER_OPTIONS)
1991     {
1992         OIC_LOG(ERROR, TAG,
1993                 "The request info numOptions is greater than MAX_HEADER_OPTIONS");
1994         SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_BAD_OPT,
1995                 requestInfo->info.type, requestInfo->info.numOptions,
1996                 requestInfo->info.options, requestInfo->info.token,
1997                 requestInfo->info.tokenLength, requestInfo->info.resourceUri,
1998                 CA_RESPONSE_DATA);
1999         OICFree(serverRequest.payload);
2000         OICFree(serverRequest.requestToken);
2001         return;
2002     }
2003     serverRequest.numRcvdVendorSpecificHeaderOptions = tempNum;
2004     if (serverRequest.numRcvdVendorSpecificHeaderOptions)
2005     {
2006         memcpy (&(serverRequest.rcvdVendorSpecificHeaderOptions), requestInfo->info.options,
2007             sizeof(CAHeaderOption_t)*tempNum);
2008     }
2009
2010     requestResult = HandleStackRequests (&serverRequest);
2011
2012     // Send ACK to client as precursor to slow response
2013     if (requestResult == OC_STACK_SLOW_RESOURCE)
2014     {
2015         if (requestInfo->info.type == CA_MSG_CONFIRM)
2016         {
2017             SendDirectStackResponse(endPoint, requestInfo->info.messageId, CA_EMPTY,
2018                                     CA_MSG_ACKNOWLEDGE,0, NULL, NULL, 0, NULL,
2019                                     CA_RESPONSE_DATA);
2020         }
2021     }
2022     if (requestResult == OC_STACK_RESOURCE_ERROR
2023             && serverRequest.observationOption == OC_OBSERVE_REGISTER)
2024     {
2025         OIC_LOG_V(ERROR, TAG, "Observe Registration failed due to resource error");
2026     }
2027     else if(!OCResultToSuccess(requestResult))
2028     {
2029         OIC_LOG_V(ERROR, TAG, "HandleStackRequests failed. error: %d", requestResult);
2030
2031         CAResponseResult_t stackResponse =
2032             OCToCAStackResult(requestResult, serverRequest.method);
2033
2034         SendDirectStackResponse(endPoint, requestInfo->info.messageId, stackResponse,
2035                 requestInfo->info.type, requestInfo->info.numOptions,
2036                 requestInfo->info.options, requestInfo->info.token,
2037                 requestInfo->info.tokenLength, requestInfo->info.resourceUri,
2038                 CA_RESPONSE_DATA);
2039     }
2040     // requestToken is fed to HandleStackRequests, which then goes to AddServerRequest.
2041     // The token is copied in there, and is thus still owned by this function.
2042     OICFree(serverRequest.payload);
2043     OICFree(serverRequest.requestToken);
2044     OIC_LOG(INFO, TAG, "Exit OCHandleRequests");
2045 }
2046
2047 //This function will be called back by CA layer when a request is received
2048 void HandleCARequests(const CAEndpoint_t* endPoint, const CARequestInfo_t* requestInfo)
2049 {
2050     OIC_LOG(INFO, TAG, "Enter HandleCARequests");
2051     if(!endPoint)
2052     {
2053         OIC_LOG(ERROR, TAG, "endPoint is NULL");
2054         return;
2055     }
2056
2057     if(!requestInfo)
2058     {
2059         OIC_LOG(ERROR, TAG, "requestInfo is NULL");
2060         return;
2061     }
2062
2063 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
2064 #ifdef ROUTING_GATEWAY
2065     bool needRIHandling = false;
2066     bool isEmptyMsg = false;
2067     /*
2068      * Routing manager is going to update either of endpoint or request or both.
2069      * This typecasting is done to avoid unnecessary duplication of Endpoint and requestInfo
2070      * RM can update "routeData" option in endPoint so that future RI requests can be sent to proper
2071      * destination. It can also remove "RM" coap header option before passing request / response to
2072      * RI as this option will make no sense to either RI or application.
2073      */
2074     OCStackResult ret = RMHandleRequest((CARequestInfo_t *)requestInfo, (CAEndpoint_t *)endPoint,
2075                                         &needRIHandling, &isEmptyMsg);
2076     if(OC_STACK_OK != ret || !needRIHandling)
2077     {
2078         OIC_LOG_V(INFO, TAG, "Routing status![%d]. Not forwarding to RI", ret);
2079         return;
2080     }
2081 #endif
2082
2083     /*
2084      * Put source in sender endpoint so that the next packet from application can be routed to
2085      * proper destination and remove RM header option.
2086      */
2087     RMUpdateInfo((CAHeaderOption_t **) &(requestInfo->info.options),
2088                  (uint8_t *) &(requestInfo->info.numOptions),
2089                  (CAEndpoint_t *) endPoint);
2090
2091 #ifdef ROUTING_GATEWAY
2092     if (isEmptyMsg)
2093     {
2094         /*
2095          * In Gateways, the MSGType in route option is used to check if the actual
2096          * response is EMPTY message(4 bytes CoAP Header).  In case of Client, the
2097          * EMPTY response is sent in the form of POST request which need to be changed
2098          * to a EMPTY response by RM.  This translation is done in this part of the code.
2099          */
2100         OIC_LOG(INFO, TAG, "This is a Empty response from the Client");
2101         CAResponseInfo_t respInfo = {.result = CA_EMPTY,
2102                                      .info.messageId = requestInfo->info.messageId,
2103                                      .info.type = CA_MSG_ACKNOWLEDGE};
2104         OCHandleResponse(endPoint, &respInfo);
2105     }
2106     else
2107 #endif
2108 #endif
2109     {
2110         // Normal handling of the packet
2111         OCHandleRequests(endPoint, requestInfo);
2112     }
2113     OIC_LOG(INFO, TAG, "Exit HandleCARequests");
2114 }
2115
2116 bool validatePlatformInfo(OCPlatformInfo info)
2117 {
2118
2119     if (!info.platformID)
2120     {
2121         OIC_LOG(ERROR, TAG, "No platform ID found.");
2122         return false;
2123     }
2124
2125     if (info.manufacturerName)
2126     {
2127         size_t lenManufacturerName = strlen(info.manufacturerName);
2128
2129         if(lenManufacturerName == 0 || lenManufacturerName > MAX_MANUFACTURER_NAME_LENGTH)
2130         {
2131             OIC_LOG(ERROR, TAG, "Manufacturer name fails length requirements.");
2132             return false;
2133         }
2134     }
2135     else
2136     {
2137         OIC_LOG(ERROR, TAG, "No manufacturer name present");
2138         return false;
2139     }
2140
2141     if (info.manufacturerUrl)
2142     {
2143         if(strlen(info.manufacturerUrl) > MAX_MANUFACTURER_URL_LENGTH)
2144         {
2145             OIC_LOG(ERROR, TAG, "Manufacturer url fails length requirements.");
2146             return false;
2147         }
2148     }
2149     return true;
2150 }
2151
2152 //-----------------------------------------------------------------------------
2153 // Public APIs
2154 //-----------------------------------------------------------------------------
2155 #ifdef RA_ADAPTER
2156 OCStackResult OCSetRAInfo(const OCRAInfo_t *raInfo)
2157 {
2158     if (!raInfo           ||
2159         !raInfo->username ||
2160         !raInfo->hostname ||
2161         !raInfo->xmpp_domain)
2162     {
2163
2164         return OC_STACK_INVALID_PARAM;
2165     }
2166     OCStackResult result = CAResultToOCResult(CASetRAInfo((const CARAInfo_t *) raInfo));
2167     gRASetInfo = (result == OC_STACK_OK)? true : false;
2168
2169     return result;
2170 }
2171 #endif
2172
2173 OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
2174 {
2175     (void) ipAddr;
2176     (void) port;
2177     return OCInit1(mode, OC_DEFAULT_FLAGS, OC_DEFAULT_FLAGS);
2178 }
2179
2180 OCStackResult OCInit1(OCMode mode, OCTransportFlags serverFlags, OCTransportFlags clientFlags)
2181 {
2182     if(stackState == OC_STACK_INITIALIZED)
2183     {
2184         OIC_LOG(INFO, TAG, "Subsequent calls to OCInit() without calling \
2185                 OCStop() between them are ignored.");
2186         return OC_STACK_OK;
2187     }
2188
2189 #ifndef ROUTING_GATEWAY
2190     if (OC_GATEWAY == mode)
2191     {
2192         OIC_LOG(ERROR, TAG, "Routing Manager not supported");
2193         return OC_STACK_INVALID_PARAM;
2194     }
2195 #endif
2196
2197 #ifdef RA_ADAPTER
2198     if(!gRASetInfo)
2199     {
2200         OIC_LOG(ERROR, TAG, "Need to call OCSetRAInfo before calling OCInit");
2201         return OC_STACK_ERROR;
2202     }
2203 #endif
2204
2205     OCStackResult result = OC_STACK_ERROR;
2206     OIC_LOG(INFO, TAG, "Entering OCInit");
2207
2208     // Validate mode
2209     if (!((mode == OC_CLIENT) || (mode == OC_SERVER) || (mode == OC_CLIENT_SERVER)
2210         || (mode == OC_GATEWAY)))
2211     {
2212         OIC_LOG(ERROR, TAG, "Invalid mode");
2213         return OC_STACK_ERROR;
2214     }
2215     myStackMode = mode;
2216
2217     if (mode == OC_CLIENT || mode == OC_CLIENT_SERVER || mode == OC_GATEWAY)
2218     {
2219         caglobals.client = true;
2220     }
2221     if (mode == OC_SERVER || mode == OC_CLIENT_SERVER || mode == OC_GATEWAY)
2222     {
2223         caglobals.server = true;
2224     }
2225
2226     caglobals.serverFlags = (CATransportFlags_t)serverFlags;
2227     if (!(caglobals.serverFlags & CA_IPFAMILY_MASK))
2228     {
2229         caglobals.serverFlags = (CATransportFlags_t)(caglobals.serverFlags|CA_IPV4|CA_IPV6);
2230     }
2231     caglobals.clientFlags = (CATransportFlags_t)clientFlags;
2232     if (!(caglobals.clientFlags & CA_IPFAMILY_MASK))
2233     {
2234         caglobals.clientFlags = (CATransportFlags_t)(caglobals.clientFlags|CA_IPV4|CA_IPV6);
2235     }
2236
2237     defaultDeviceHandler = NULL;
2238     defaultDeviceHandlerCallbackParameter = NULL;
2239
2240     result = InitializeScheduleResourceList();
2241     VERIFY_SUCCESS(result, OC_STACK_OK);
2242
2243     result = CAResultToOCResult(CAInitialize());
2244     VERIFY_SUCCESS(result, OC_STACK_OK);
2245
2246     result = CAResultToOCResult(OCSelectNetwork());
2247     VERIFY_SUCCESS(result, OC_STACK_OK);
2248
2249     result = CAResultToOCResult(CARegisterNetworkMonitorHandler(
2250       OCDefaultAdapterStateChangedHandler, OCDefaultConnectionStateChangedHandler));
2251     VERIFY_SUCCESS(result, OC_STACK_OK);
2252
2253     switch (myStackMode)
2254     {
2255         case OC_CLIENT:
2256             CARegisterHandler(HandleCARequests, HandleCAResponses, HandleCAErrorResponse);
2257             result = CAResultToOCResult(CAStartDiscoveryServer());
2258             OIC_LOG(INFO, TAG, "Client mode: CAStartDiscoveryServer");
2259             break;
2260         case OC_SERVER:
2261             SRMRegisterHandler(HandleCARequests, HandleCAResponses, HandleCAErrorResponse);
2262             result = CAResultToOCResult(CAStartListeningServer());
2263             OIC_LOG(INFO, TAG, "Server mode: CAStartListeningServer");
2264             break;
2265         case OC_CLIENT_SERVER:
2266         case OC_GATEWAY:
2267             SRMRegisterHandler(HandleCARequests, HandleCAResponses, HandleCAErrorResponse);
2268             result = CAResultToOCResult(CAStartListeningServer());
2269             if(result == OC_STACK_OK)
2270             {
2271                 result = CAResultToOCResult(CAStartDiscoveryServer());
2272             }
2273             break;
2274     }
2275     VERIFY_SUCCESS(result, OC_STACK_OK);
2276
2277 #ifdef TCP_ADAPTER
2278     CARegisterKeepAliveHandler(HandleKeepAliveConnCB);
2279 #endif
2280
2281 #ifdef WITH_PRESENCE
2282     PresenceTimeOutSize = sizeof (PresenceTimeOut) / sizeof (PresenceTimeOut[0]) - 1;
2283 #endif // WITH_PRESENCE
2284
2285     //Update Stack state to initialized
2286     stackState = OC_STACK_INITIALIZED;
2287
2288     // Initialize resource
2289     if(myStackMode != OC_CLIENT)
2290     {
2291         result = initResources();
2292     }
2293
2294     // Initialize the SRM Policy Engine
2295     if(result == OC_STACK_OK)
2296     {
2297         result = SRMInitPolicyEngine();
2298         // TODO after BeachHead delivery: consolidate into single SRMInit()
2299     }
2300 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
2301     RMSetStackMode(mode);
2302 #ifdef ROUTING_GATEWAY
2303     if (OC_GATEWAY == myStackMode)
2304     {
2305         result = RMInitialize();
2306     }
2307 #endif
2308 #endif
2309
2310 #ifdef TCP_ADAPTER
2311     if (result == OC_STACK_OK)
2312     {
2313         result = InitializeKeepAlive(myStackMode);
2314     }
2315 #endif
2316
2317 exit:
2318     if(result != OC_STACK_OK)
2319     {
2320         OIC_LOG(ERROR, TAG, "Stack initialization error");
2321         deleteAllResources();
2322         CATerminate();
2323         TerminateScheduleResourceList();
2324         stackState = OC_STACK_UNINITIALIZED;
2325     }
2326     return result;
2327 }
2328
2329 OCStackResult OCStop()
2330 {
2331     OIC_LOG(INFO, TAG, "Entering OCStop");
2332
2333     if (stackState == OC_STACK_UNINIT_IN_PROGRESS)
2334     {
2335         OIC_LOG(DEBUG, TAG, "Stack already stopping, exiting");
2336         return OC_STACK_OK;
2337     }
2338     else if (stackState != OC_STACK_INITIALIZED)
2339     {
2340         OIC_LOG(ERROR, TAG, "Stack not initialized");
2341         return OC_STACK_ERROR;
2342     }
2343
2344     stackState = OC_STACK_UNINIT_IN_PROGRESS;
2345
2346 #ifdef WITH_PRESENCE
2347     // Ensure that the TTL associated with ANY and ALL presence notifications originating from
2348     // here send with the code "OC_STACK_PRESENCE_STOPPED" result.
2349     presenceResource.presenceTTL = 0;
2350 #endif // WITH_PRESENCE
2351
2352 #ifdef ROUTING_GATEWAY
2353     if (OC_GATEWAY == myStackMode)
2354     {
2355         RMTerminate();
2356     }
2357 #endif
2358
2359 #ifdef TCP_ADAPTER
2360     TerminateKeepAlive(myStackMode);
2361 #endif
2362
2363     // Free memory dynamically allocated for resources
2364     deleteAllResources();
2365     DeleteDeviceInfo();
2366     DeletePlatformInfo();
2367     CATerminate();
2368     TerminateScheduleResourceList();
2369     // Remove all observers
2370     DeleteObserverList();
2371     // Remove all the client callbacks
2372     DeleteClientCBList();
2373
2374     // De-init the SRM Policy Engine
2375     // TODO after BeachHead delivery: consolidate into single SRMDeInit()
2376     SRMDeInitPolicyEngine();
2377
2378
2379     stackState = OC_STACK_UNINITIALIZED;
2380     return OC_STACK_OK;
2381 }
2382
2383 OCStackResult OCStartMulticastServer()
2384 {
2385     if(stackState != OC_STACK_INITIALIZED)
2386     {
2387         OIC_LOG(ERROR, TAG, "OCStack is not initalized. Cannot start multicast server.");
2388         return OC_STACK_ERROR;
2389     }
2390     CAResult_t ret = CAStartListeningServer();
2391     if (CA_STATUS_OK != ret)
2392     {
2393         OIC_LOG_V(ERROR, TAG, "Failed starting listening server: %d", ret);
2394         return OC_STACK_ERROR;
2395     }
2396     return OC_STACK_OK;
2397 }
2398
2399 OCStackResult OCStopMulticastServer()
2400 {
2401     CAResult_t ret = CAStopListeningServer();
2402     if (CA_STATUS_OK != ret)
2403     {
2404         OIC_LOG_V(ERROR, TAG, "Failed stopping listening server: %d", ret);
2405         return OC_STACK_ERROR;
2406     }
2407     return OC_STACK_OK;
2408 }
2409
2410 CAMessageType_t qualityOfServiceToMessageType(OCQualityOfService qos)
2411 {
2412     switch (qos)
2413     {
2414         case OC_HIGH_QOS:
2415             return CA_MSG_CONFIRM;
2416         case OC_LOW_QOS:
2417         case OC_MEDIUM_QOS:
2418         case OC_NA_QOS:
2419         default:
2420             return CA_MSG_NONCONFIRM;
2421     }
2422 }
2423
2424 /**
2425  *  A request uri consists of the following components in order:
2426  *                              example
2427  *  optionally one of
2428  *      CoAP over UDP prefix    "coap://"
2429  *      CoAP over TCP prefix    "coap+tcp://"
2430  *      CoAP over DTLS prefix   "coaps://"
2431  *      CoAP over TLS prefix    "coaps+tcp://"
2432  *  optionally one of
2433  *      IPv6 address            "[1234::5678]"
2434  *      IPv4 address            "192.168.1.1"
2435  *  optional port               ":5683"
2436  *  resource uri                "/oc/core..."
2437  *
2438  *  for PRESENCE requests, extract resource type.
2439  */
2440 static OCStackResult ParseRequestUri(const char *fullUri,
2441                                         OCTransportAdapter adapter,
2442                                         OCTransportFlags flags,
2443                                         OCDevAddr **devAddr,
2444                                         char **resourceUri,
2445                                         char **resourceType)
2446 {
2447     VERIFY_NON_NULL(fullUri, FATAL, OC_STACK_INVALID_CALLBACK);
2448
2449     OCStackResult result = OC_STACK_OK;
2450     OCDevAddr *da = NULL;
2451     char *colon = NULL;
2452     char *end;
2453
2454     // provide defaults for all returned values
2455     if (devAddr)
2456     {
2457         *devAddr = NULL;
2458     }
2459     if (resourceUri)
2460     {
2461         *resourceUri = NULL;
2462     }
2463     if (resourceType)
2464     {
2465         *resourceType = NULL;
2466     }
2467
2468     // delimit url prefix, if any
2469     const char *start = fullUri;
2470     char *slash2 = strstr(start, "//");
2471     if (slash2)
2472     {
2473         start = slash2 + 2;
2474     }
2475     char *slash = strchr(start, '/');
2476     if (!slash)
2477     {
2478         return OC_STACK_INVALID_URI;
2479     }
2480
2481     // process url scheme
2482     size_t prefixLen = slash2 - fullUri;
2483     bool istcp = false;
2484     if (prefixLen)
2485     {
2486         if (((prefixLen == sizeof(COAP_TCP_SCHEME) - 1) && (!strncmp(fullUri, COAP_TCP_SCHEME, prefixLen)))
2487         || ((prefixLen == sizeof(COAPS_TCP_SCHEME) - 1) && (!strncmp(fullUri, COAPS_TCP_SCHEME, prefixLen))))
2488         {
2489             istcp = true;
2490         }
2491     }
2492
2493     // TODO: this logic should come in with unit tests exercising the various strings
2494     // processs url prefix, if any
2495     size_t urlLen = slash - start;
2496     // port
2497     uint16_t port = 0;
2498     size_t len = 0;
2499     if (urlLen && devAddr)
2500     {   // construct OCDevAddr
2501         if (start[0] == '[')
2502         {   // ipv6 address
2503             char *close = strchr(++start, ']');
2504             if (!close || close > slash)
2505             {
2506                 return OC_STACK_INVALID_URI;
2507             }
2508             end = close;
2509             if (close[1] == ':')
2510             {
2511                 colon = close + 1;
2512             }
2513
2514             if (istcp)
2515             {
2516                 adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_TCP);
2517             }
2518             else
2519             {
2520                 adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_IP);
2521             }
2522             flags = (OCTransportFlags)(flags | OC_IP_USE_V6);
2523         }
2524         else
2525         {
2526             char *dot = strchr(start, '.');
2527             if (dot && dot < slash)
2528             {   // ipv4 address
2529                 colon = strchr(start, ':');
2530                 end = (colon && colon < slash) ? colon : slash;
2531
2532                 if (istcp)
2533                 {
2534                     // coap over tcp
2535                     adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_TCP);
2536                 }
2537                 else
2538                 {
2539                     adapter = (OCTransportAdapter)(adapter | OC_ADAPTER_IP);
2540                 }
2541                 flags = (OCTransportFlags)(flags | OC_IP_USE_V4);
2542             }
2543             else
2544             {   // MAC address
2545                 end = slash;
2546             }
2547         }
2548         len = end - start;
2549         if (len >= sizeof(da->addr))
2550         {
2551             return OC_STACK_INVALID_URI;
2552         }
2553         // collect port, if any
2554         if (colon && colon < slash)
2555         {
2556             for (colon++; colon < slash; colon++)
2557             {
2558                 char c = colon[0];
2559                 if (c < '0' || c > '9')
2560                 {
2561                     return OC_STACK_INVALID_URI;
2562                 }
2563                 port = 10 * port + c - '0';
2564             }
2565         }
2566
2567         len = end - start;
2568         if (len >= sizeof(da->addr))
2569         {
2570             return OC_STACK_INVALID_URI;
2571         }
2572
2573         da = (OCDevAddr *)OICCalloc(sizeof (OCDevAddr), 1);
2574         if (!da)
2575         {
2576             return OC_STACK_NO_MEMORY;
2577         }
2578         OICStrcpyPartial(da->addr, sizeof(da->addr), start, len);
2579         da->port = port;
2580         da->adapter = adapter;
2581         da->flags = flags;
2582         if (!strncmp(fullUri, "coaps", 5))
2583         {
2584             da->flags = (OCTransportFlags)(da->flags|CA_SECURE);
2585         }
2586         *devAddr = da;
2587     }
2588
2589     // process resource uri, if any
2590     if (slash)
2591     {   // request uri and query
2592         size_t ulen = strlen(slash); // resource uri length
2593         size_t tlen = 0;      // resource type length
2594         char *type = NULL;
2595
2596         static const char strPresence[] = "/oic/ad?rt=";
2597         static const size_t lenPresence = sizeof(strPresence) - 1;
2598         if (!strncmp(slash, strPresence, lenPresence))
2599         {
2600             type = slash + lenPresence;
2601             tlen = ulen - lenPresence;
2602         }
2603         // resource uri
2604         if (resourceUri)
2605         {
2606             *resourceUri = (char *)OICMalloc(ulen + 1);
2607             if (!*resourceUri)
2608             {
2609                 result = OC_STACK_NO_MEMORY;
2610                 goto error;
2611             }
2612             strcpy(*resourceUri, slash);
2613         }
2614         // resource type
2615         if (type && resourceType)
2616         {
2617             *resourceType = (char *)OICMalloc(tlen + 1);
2618             if (!*resourceType)
2619             {
2620                 result = OC_STACK_NO_MEMORY;
2621                 goto error;
2622             }
2623
2624             OICStrcpy(*resourceType, (tlen+1), type);
2625         }
2626     }
2627
2628     return OC_STACK_OK;
2629
2630 error:
2631     // free all returned values
2632     if (devAddr)
2633     {
2634         OICFree(*devAddr);
2635     }
2636     if (resourceUri)
2637     {
2638         OICFree(*resourceUri);
2639     }
2640     if (resourceType)
2641     {
2642         OICFree(*resourceType);
2643     }
2644     return result;
2645 }
2646
2647 static OCStackResult OCPreparePresence(CAEndpoint_t *endpoint,
2648                                        char *resourceUri,
2649                                        char **requestUri,
2650                                        bool isMulticast)
2651 {
2652     char uri[CA_MAX_URI_LENGTH];
2653
2654     FormCanonicalPresenceUri(endpoint, resourceUri, uri, isMulticast);
2655
2656     *requestUri = OICStrdup(uri);
2657     if (!*requestUri)
2658     {
2659         return OC_STACK_NO_MEMORY;
2660     }
2661
2662     return OC_STACK_OK;
2663 }
2664
2665 /**
2666  * Discover or Perform requests on a specified resource
2667  */
2668 OCStackResult OCDoResource(OCDoHandle *handle,
2669                             OCMethod method,
2670                             const char *requestUri,
2671                             const OCDevAddr *destination,
2672                             OCPayload* payload,
2673                             OCConnectivityType connectivityType,
2674                             OCQualityOfService qos,
2675                             OCCallbackData *cbData,
2676                             OCHeaderOption *options,
2677                             uint8_t numOptions)
2678 {
2679     OIC_LOG(INFO, TAG, "Entering OCDoResource");
2680
2681     // Validate input parameters
2682     VERIFY_NON_NULL(cbData, FATAL, OC_STACK_INVALID_CALLBACK);
2683     VERIFY_NON_NULL(cbData->cb, FATAL, OC_STACK_INVALID_CALLBACK);
2684
2685     OCStackResult result = OC_STACK_ERROR;
2686     CAResult_t caResult;
2687     CAToken_t token = NULL;
2688     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
2689     ClientCB *clientCB = NULL;
2690     OCDoHandle resHandle = NULL;
2691     CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_ADAPTER};
2692     OCDevAddr tmpDevAddr = { OC_DEFAULT_ADAPTER };
2693     uint32_t ttl = 0;
2694     OCTransportAdapter adapter;
2695     OCTransportFlags flags;
2696     // the request contents are put here
2697     CARequestInfo_t requestInfo = {.method = CA_GET};
2698     // requestUri  will be parsed into the following three variables
2699     OCDevAddr *devAddr = NULL;
2700     char *resourceUri = NULL;
2701     char *resourceType = NULL;
2702
2703     /*
2704      * Support original behavior with address on resourceUri argument.
2705      */
2706     adapter = (OCTransportAdapter)(connectivityType >> CT_ADAPTER_SHIFT);
2707     flags = (OCTransportFlags)(connectivityType & CT_MASK_FLAGS);
2708
2709     if (requestUri)
2710     {
2711         result = ParseRequestUri(requestUri, adapter, flags, &devAddr, &resourceUri, &resourceType);
2712         if (result != OC_STACK_OK)
2713         {
2714             OIC_LOG_V(DEBUG, TAG, "Unable to parse uri: %s", requestUri);
2715             goto exit;
2716         }
2717     }
2718     else if (!checkProxyUri(options, numOptions))
2719     {
2720         OIC_LOG(ERROR, TAG, "Request doesn't contain RequestURI/Proxy URI");
2721         goto exit;
2722     }
2723
2724     switch (method)
2725     {
2726     case OC_REST_GET:
2727     case OC_REST_OBSERVE:
2728     case OC_REST_OBSERVE_ALL:
2729         requestInfo.method = CA_GET;
2730         break;
2731     case OC_REST_PUT:
2732         requestInfo.method = CA_PUT;
2733         break;
2734     case OC_REST_POST:
2735         requestInfo.method = CA_POST;
2736         break;
2737     case OC_REST_DELETE:
2738         requestInfo.method = CA_DELETE;
2739         break;
2740     case OC_REST_DISCOVER:
2741         qos = OC_LOW_QOS;
2742 #ifdef WITH_PRESENCE
2743     case OC_REST_PRESENCE:
2744 #endif
2745         if (destination || devAddr)
2746         {
2747             requestInfo.isMulticast = false;
2748         }
2749         else
2750         {
2751             tmpDevAddr.adapter = adapter;
2752             tmpDevAddr.flags = flags;
2753             destination = &tmpDevAddr;
2754             requestInfo.isMulticast = true;
2755         }
2756         // OC_REST_DISCOVER: CA_DISCOVER will become GET and isMulticast.
2757         // OC_REST_PRESENCE: Since "presence" is a stack layer only implementation.
2758         //                   replacing method type with GET.
2759         requestInfo.method = CA_GET;
2760         break;
2761     default:
2762         result = OC_STACK_INVALID_METHOD;
2763         goto exit;
2764     }
2765
2766     if (!devAddr && !destination)
2767     {
2768         OIC_LOG(DEBUG, TAG, "no devAddr and no destination");
2769         result = OC_STACK_INVALID_PARAM;
2770         goto exit;
2771     }
2772
2773     /* If not original behavior, use destination argument */
2774     if (destination && !devAddr)
2775     {
2776         devAddr = (OCDevAddr *)OICMalloc(sizeof (OCDevAddr));
2777         if (!devAddr)
2778         {
2779             result = OC_STACK_NO_MEMORY;
2780             goto exit;
2781         }
2782         *devAddr = *destination;
2783     }
2784
2785     resHandle = GenerateInvocationHandle();
2786     if (!resHandle)
2787     {
2788         result = OC_STACK_NO_MEMORY;
2789         goto exit;
2790     }
2791
2792     caResult = CAGenerateToken(&token, tokenLength);
2793     if (caResult != CA_STATUS_OK)
2794     {
2795         OIC_LOG(ERROR, TAG, "CAGenerateToken error");
2796         result= OC_STACK_ERROR;
2797         goto exit;
2798     }
2799
2800     // fill in request data
2801     requestInfo.info.type = qualityOfServiceToMessageType(qos);
2802     requestInfo.info.token = token;
2803     requestInfo.info.tokenLength = tokenLength;
2804     requestInfo.info.resourceUri = resourceUri;
2805
2806     if ((method == OC_REST_OBSERVE) || (method == OC_REST_OBSERVE_ALL))
2807     {
2808         result = CreateObserveHeaderOption (&(requestInfo.info.options),
2809                                     options, numOptions, OC_OBSERVE_REGISTER);
2810         if (result != OC_STACK_OK)
2811         {
2812             goto exit;
2813         }
2814         requestInfo.info.numOptions = numOptions + 1;
2815     }
2816     else
2817     {
2818         requestInfo.info.numOptions = numOptions;
2819         requestInfo.info.options =
2820             (CAHeaderOption_t*) OICCalloc(numOptions, sizeof(CAHeaderOption_t));
2821         memcpy(requestInfo.info.options, (CAHeaderOption_t*)options,
2822                numOptions * sizeof(CAHeaderOption_t));
2823     }
2824
2825     CopyDevAddrToEndpoint(devAddr, &endpoint);
2826
2827     if(payload)
2828     {
2829         if((result =
2830             OCConvertPayload(payload, &requestInfo.info.payload, &requestInfo.info.payloadSize))
2831                 != OC_STACK_OK)
2832         {
2833             OIC_LOG(ERROR, TAG, "Failed to create CBOR Payload");
2834             goto exit;
2835         }
2836         requestInfo.info.payloadFormat = CA_FORMAT_APPLICATION_CBOR;
2837     }
2838     else
2839     {
2840         requestInfo.info.payload = NULL;
2841         requestInfo.info.payloadSize = 0;
2842         requestInfo.info.payloadFormat = CA_FORMAT_UNDEFINED;
2843     }
2844
2845     // prepare for response
2846 #ifdef WITH_PRESENCE
2847     if (method == OC_REST_PRESENCE)
2848     {
2849         char *presenceUri = NULL;
2850         result = OCPreparePresence(&endpoint, resourceUri, &presenceUri,
2851                                    requestInfo.isMulticast);
2852         if (OC_STACK_OK != result)
2853         {
2854             goto exit;
2855         }
2856
2857         // Assign full presence uri as coap://ip:port/oic/ad to add to callback list.
2858         // Presence notification will form a canonical uri to
2859         // look for callbacks into the application.
2860         resourceUri = presenceUri;
2861     }
2862 #endif
2863
2864     ttl = GetTicks(MAX_CB_TIMEOUT_SECONDS * MILLISECONDS_PER_SECOND);
2865     result = AddClientCB(&clientCB, cbData, token, tokenLength, &resHandle,
2866                             method, devAddr, resourceUri, resourceType, ttl);
2867     if (OC_STACK_OK != result)
2868     {
2869         goto exit;
2870     }
2871
2872     devAddr = NULL;       // Client CB list entry now owns it
2873     resourceUri = NULL;   // Client CB list entry now owns it
2874     resourceType = NULL;  // Client CB list entry now owns it
2875
2876     // send request
2877     result = OCSendRequest(&endpoint, &requestInfo);
2878     if (OC_STACK_OK != result)
2879     {
2880         goto exit;
2881     }
2882
2883     if (handle)
2884     {
2885         *handle = resHandle;
2886     }
2887
2888 exit:
2889     if (result != OC_STACK_OK)
2890     {
2891         OIC_LOG(ERROR, TAG, "OCDoResource error");
2892         FindAndDeleteClientCB(clientCB);
2893         CADestroyToken(token);
2894         if (handle)
2895         {
2896             *handle = NULL;
2897         }
2898         OICFree(resHandle);
2899     }
2900
2901     // This is the owner of the payload object, so we free it
2902     OCPayloadDestroy(payload);
2903     OICFree(requestInfo.info.payload);
2904     OICFree(devAddr);
2905     OICFree(resourceUri);
2906     OICFree(resourceType);
2907     OICFree(requestInfo.info.options);
2908     return result;
2909 }
2910
2911 OCStackResult OCCancel(OCDoHandle handle, OCQualityOfService qos, OCHeaderOption * options,
2912         uint8_t numOptions)
2913 {
2914     /*
2915      * This ftn is implemented one of two ways in the case of observation:
2916      *
2917      * 1. qos == OC_NON_CONFIRMABLE. When observe is unobserved..
2918      *      Remove the callback associated on client side.
2919      *      When the next notification comes in from server,
2920      *      reply with RESET message to server.
2921      *      Keep in mind that the server will react to RESET only
2922      *      if the last notification was sent as CON
2923      *
2924      * 2. qos == OC_CONFIRMABLE. When OCCancel is called,
2925      *      and it is associated with an observe request
2926      *      (i.e. ClientCB->method == OC_REST_OBSERVE || OC_REST_OBSERVE_ALL),
2927      *      Send CON Observe request to server with
2928      *      observe flag = OC_RESOURCE_OBSERVE_DEREGISTER.
2929      *      Remove the callback associated on client side.
2930      */
2931     OCStackResult ret = OC_STACK_OK;
2932     CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_ADAPTER};
2933     CARequestInfo_t requestInfo = {.method = CA_GET};
2934
2935     if(!handle)
2936     {
2937         return OC_STACK_INVALID_PARAM;
2938     }
2939
2940     ClientCB *clientCB = GetClientCB(NULL, 0, handle, NULL);
2941     if (!clientCB)
2942     {
2943         OIC_LOG(ERROR, TAG, "Callback not found. Called OCCancel on same resource twice?");
2944         return OC_STACK_ERROR;
2945     }
2946
2947     switch (clientCB->method)
2948     {
2949         case OC_REST_OBSERVE:
2950         case OC_REST_OBSERVE_ALL:
2951
2952             OIC_LOG_V(INFO, TAG, "Canceling observation for resource %s", clientCB->requestUri);
2953
2954             CopyDevAddrToEndpoint(clientCB->devAddr, &endpoint);
2955
2956             if ((endpoint.adapter & CA_ADAPTER_IP) && qos != OC_HIGH_QOS)
2957             {
2958                 FindAndDeleteClientCB(clientCB);
2959                 break;
2960             }
2961
2962             OIC_LOG(INFO, TAG, "Cancelling observation as CONFIRMABLE");
2963
2964             requestInfo.info.type = qualityOfServiceToMessageType(qos);
2965             requestInfo.info.token = clientCB->token;
2966             requestInfo.info.tokenLength = clientCB->tokenLength;
2967
2968             if (CreateObserveHeaderOption (&(requestInfo.info.options),
2969                     options, numOptions, OC_OBSERVE_DEREGISTER) != OC_STACK_OK)
2970             {
2971                 return OC_STACK_ERROR;
2972             }
2973             requestInfo.info.numOptions = numOptions + 1;
2974             requestInfo.info.resourceUri = OICStrdup (clientCB->requestUri);
2975
2976
2977             ret = OCSendRequest(&endpoint, &requestInfo);
2978
2979             if (requestInfo.info.options)
2980             {
2981                 OICFree (requestInfo.info.options);
2982             }
2983             if (requestInfo.info.resourceUri)
2984             {
2985                 OICFree (requestInfo.info.resourceUri);
2986             }
2987
2988             break;
2989
2990         case OC_REST_DISCOVER:
2991             OIC_LOG_V(INFO, TAG, "Cancelling discovery callback for resource %s",
2992                                            clientCB->requestUri);
2993             FindAndDeleteClientCB(clientCB);
2994             break;
2995
2996 #ifdef WITH_PRESENCE
2997         case OC_REST_PRESENCE:
2998             FindAndDeleteClientCB(clientCB);
2999             break;
3000 #endif
3001
3002         default:
3003             ret = OC_STACK_INVALID_METHOD;
3004             break;
3005     }
3006
3007     return ret;
3008 }
3009
3010 /**
3011  * @brief   Register Persistent storage callback.
3012  * @param   persistentStorageHandler [IN] Pointers to open, read, write, close & unlink handlers.
3013  * @return
3014  *     OC_STACK_OK    - No errors; Success
3015  *     OC_STACK_INVALID_PARAM - Invalid parameter
3016  */
3017 OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
3018 {
3019     OIC_LOG(INFO, TAG, "RegisterPersistentStorageHandler !!");
3020     if(!persistentStorageHandler)
3021     {
3022         OIC_LOG(ERROR, TAG, "The persistent storage handler is invalid");
3023         return OC_STACK_INVALID_PARAM;
3024     }
3025     else
3026     {
3027         if( !persistentStorageHandler->open ||
3028                 !persistentStorageHandler->close ||
3029                 !persistentStorageHandler->read ||
3030                 !persistentStorageHandler->unlink ||
3031                 !persistentStorageHandler->write)
3032         {
3033             OIC_LOG(ERROR, TAG, "The persistent storage handler is invalid");
3034             return OC_STACK_INVALID_PARAM;
3035         }
3036     }
3037     return SRMRegisterPersistentStorageHandler(persistentStorageHandler);
3038 }
3039
3040 #ifdef WITH_PRESENCE
3041
3042 OCStackResult OCProcessPresence()
3043 {
3044     OCStackResult result = OC_STACK_OK;
3045
3046     // the following line floods the log with messages that are irrelevant
3047     // to most purposes.  Uncomment as needed.
3048     //OIC_LOG(INFO, TAG, "Entering RequestPresence");
3049     ClientCB* cbNode = NULL;
3050     OCClientResponse clientResponse;
3051     OCStackApplicationResult cbResult = OC_STACK_DELETE_TRANSACTION;
3052
3053     LL_FOREACH(cbList, cbNode)
3054     {
3055         if (OC_REST_PRESENCE != cbNode->method || !cbNode->presence)
3056         {
3057             continue;
3058         }
3059
3060         uint32_t now = GetTicks(0);
3061         OIC_LOG_V(DEBUG, TAG, "this TTL level %d",
3062                                                 cbNode->presence->TTLlevel);
3063         OIC_LOG_V(DEBUG, TAG, "current ticks %d", now);
3064
3065         if (cbNode->presence->TTLlevel > PresenceTimeOutSize)
3066         {
3067             goto exit;
3068         }
3069
3070         if (cbNode->presence->TTLlevel < PresenceTimeOutSize)
3071         {
3072             OIC_LOG_V(DEBUG, TAG, "timeout ticks %d",
3073                     cbNode->presence->timeOut[cbNode->presence->TTLlevel]);
3074         }
3075         if (cbNode->presence->TTLlevel >= PresenceTimeOutSize)
3076         {
3077             OIC_LOG(DEBUG, TAG, "No more timeout ticks");
3078
3079             clientResponse.sequenceNumber = 0;
3080             clientResponse.result = OC_STACK_PRESENCE_TIMEOUT;
3081             clientResponse.devAddr = *cbNode->devAddr;
3082             FixUpClientResponse(&clientResponse);
3083             clientResponse.payload = NULL;
3084
3085             // Increment the TTLLevel (going to a next state), so we don't keep
3086             // sending presence notification to client.
3087             cbNode->presence->TTLlevel++;
3088             OIC_LOG_V(DEBUG, TAG, "moving to TTL level %d",
3089                                         cbNode->presence->TTLlevel);
3090
3091             cbResult = cbNode->callBack(cbNode->context, cbNode->handle, &clientResponse);
3092             if (cbResult == OC_STACK_DELETE_TRANSACTION)
3093             {
3094                 FindAndDeleteClientCB(cbNode);
3095             }
3096         }
3097
3098         if (now < cbNode->presence->timeOut[cbNode->presence->TTLlevel])
3099         {
3100             continue;
3101         }
3102
3103         CAEndpoint_t endpoint = {.adapter = CA_DEFAULT_ADAPTER};
3104         CAInfo_t requestData = {.type = CA_MSG_CONFIRM};
3105         CARequestInfo_t requestInfo = {.method = CA_GET};
3106
3107         OIC_LOG(DEBUG, TAG, "time to test server presence");
3108
3109         CopyDevAddrToEndpoint(cbNode->devAddr, &endpoint);
3110
3111         requestData.type = CA_MSG_NONCONFIRM;
3112         requestData.token = cbNode->token;
3113         requestData.tokenLength = cbNode->tokenLength;
3114         requestData.resourceUri = OC_RSRVD_PRESENCE_URI;
3115         requestInfo.method = CA_GET;
3116         requestInfo.info = requestData;
3117
3118         result = OCSendRequest(&endpoint, &requestInfo);
3119         if (OC_STACK_OK != result)
3120         {
3121             goto exit;
3122         }
3123
3124         cbNode->presence->TTLlevel++;
3125         OIC_LOG_V(DEBUG, TAG, "moving to TTL level %d", cbNode->presence->TTLlevel);
3126     }
3127 exit:
3128     if (result != OC_STACK_OK)
3129     {
3130         OIC_LOG(ERROR, TAG, "OCProcessPresence error");
3131     }
3132
3133     return result;
3134 }
3135 #endif // WITH_PRESENCE
3136
3137 OCStackResult OCProcess()
3138 {
3139 #ifdef WITH_PRESENCE
3140     OCProcessPresence();
3141 #endif
3142     CAHandleRequestResponse();
3143
3144 #ifdef ROUTING_GATEWAY
3145     RMProcess();
3146 #endif
3147
3148 #ifdef TCP_ADAPTER
3149     ProcessKeepAlive();
3150 #endif
3151     return OC_STACK_OK;
3152 }
3153
3154 #ifdef WITH_PRESENCE
3155 OCStackResult OCStartPresence(const uint32_t ttl)
3156 {
3157     uint8_t tokenLength = CA_MAX_TOKEN_LEN;
3158     OCChangeResourceProperty(
3159             &(((OCResource *)presenceResource.handle)->resourceProperties),
3160             OC_ACTIVE, 1);
3161
3162     if (OC_MAX_PRESENCE_TTL_SECONDS < ttl)
3163     {
3164         presenceResource.presenceTTL = OC_MAX_PRESENCE_TTL_SECONDS;
3165         OIC_LOG(INFO, TAG, "Setting Presence TTL to max value");
3166     }
3167     else if (0 == ttl)
3168     {
3169         presenceResource.presenceTTL = OC_DEFAULT_PRESENCE_TTL_SECONDS;
3170         OIC_LOG(INFO, TAG, "Setting Presence TTL to default value");
3171     }
3172     else
3173     {
3174         presenceResource.presenceTTL = ttl;
3175     }
3176     OIC_LOG_V(DEBUG, TAG, "Presence TTL is %" PRIu32 " seconds", presenceResource.presenceTTL);
3177
3178     if (OC_PRESENCE_UNINITIALIZED == presenceState)
3179     {
3180         presenceState = OC_PRESENCE_INITIALIZED;
3181
3182         OCDevAddr devAddr = { OC_DEFAULT_ADAPTER };
3183
3184         CAToken_t caToken = NULL;
3185         CAResult_t caResult = CAGenerateToken(&caToken, tokenLength);
3186         if (caResult != CA_STATUS_OK)
3187         {
3188             OIC_LOG(ERROR, TAG, "CAGenerateToken error");
3189             CADestroyToken(caToken);
3190             return OC_STACK_ERROR;
3191         }
3192
3193         AddObserver(OC_RSRVD_PRESENCE_URI, NULL, 0, caToken, tokenLength,
3194                 (OCResource *)presenceResource.handle, OC_LOW_QOS, OC_FORMAT_UNDEFINED, &devAddr);
3195         CADestroyToken(caToken);
3196     }
3197
3198     // Each time OCStartPresence is called
3199     // a different random 32-bit integer number is used
3200     ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
3201
3202     return SendPresenceNotification(((OCResource *)presenceResource.handle)->rsrcType,
3203             OC_PRESENCE_TRIGGER_CREATE);
3204 }
3205
3206 OCStackResult OCStopPresence()
3207 {
3208     OCStackResult result = OC_STACK_ERROR;
3209
3210     if(presenceResource.handle)
3211     {
3212         ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
3213
3214     // make resource inactive
3215     result = OCChangeResourceProperty(
3216             &(((OCResource *) presenceResource.handle)->resourceProperties),
3217             OC_ACTIVE, 0);
3218     }
3219
3220     if(result != OC_STACK_OK)
3221     {
3222         OIC_LOG(ERROR, TAG,
3223                       "Changing the presence resource properties to ACTIVE not successful");
3224         return result;
3225     }
3226
3227     return SendStopNotification();
3228 }
3229 #endif
3230
3231 OCStackResult OCSetDefaultDeviceEntityHandler(OCDeviceEntityHandler entityHandler,
3232                                             void* callbackParameter)
3233 {
3234     defaultDeviceHandler = entityHandler;
3235     defaultDeviceHandlerCallbackParameter = callbackParameter;
3236
3237     return OC_STACK_OK;
3238 }
3239
3240 OCStackResult OCSetPlatformInfo(OCPlatformInfo platformInfo)
3241 {
3242     OIC_LOG(INFO, TAG, "Entering OCSetPlatformInfo");
3243
3244     if(myStackMode ==  OC_SERVER || myStackMode == OC_CLIENT_SERVER || myStackMode == OC_GATEWAY)
3245     {
3246         if (validatePlatformInfo(platformInfo))
3247         {
3248             return SavePlatformInfo(platformInfo);
3249         }
3250         else
3251         {
3252             return OC_STACK_INVALID_PARAM;
3253         }
3254     }
3255     else
3256     {
3257         return OC_STACK_ERROR;
3258     }
3259 }
3260
3261 OCStackResult OCSetDeviceInfo(OCDeviceInfo deviceInfo)
3262 {
3263     OIC_LOG(INFO, TAG, "Entering OCSetDeviceInfo");
3264
3265     if (!deviceInfo.deviceName || deviceInfo.deviceName[0] == '\0')
3266     {
3267         OIC_LOG(ERROR, TAG, "Null or empty device name.");
3268         return OC_STACK_INVALID_PARAM;
3269     }
3270
3271     if (deviceInfo.types)
3272     {
3273         OCStringLL *type =  deviceInfo.types;
3274         OCResource *resource = findResource((OCResource *) deviceResource);
3275         if (!resource)
3276         {
3277             return OC_STACK_INVALID_PARAM;
3278         }
3279
3280         while (type)
3281         {
3282             OCBindResourceTypeToResource(deviceResource, type->value);
3283             type = type->next;
3284         }
3285     }
3286     return SaveDeviceInfo(deviceInfo);
3287 }
3288
3289 OCStackResult OCCreateResource(OCResourceHandle *handle,
3290         const char *resourceTypeName,
3291         const char *resourceInterfaceName,
3292         const char *uri, OCEntityHandler entityHandler,
3293         void* callbackParam,
3294         uint8_t resourceProperties)
3295 {
3296
3297     OCResource *pointer = NULL;
3298     OCStackResult result = OC_STACK_ERROR;
3299
3300     OIC_LOG(INFO, TAG, "Entering OCCreateResource");
3301
3302     if(myStackMode == OC_CLIENT)
3303     {
3304         return OC_STACK_INVALID_PARAM;
3305     }
3306     // Validate parameters
3307     if(!uri || uri[0]=='\0' || strlen(uri)>=MAX_URI_LENGTH )
3308     {
3309         OIC_LOG(ERROR, TAG, "URI is empty or too long");
3310         return OC_STACK_INVALID_URI;
3311     }
3312     // Is it presented during resource discovery?
3313     if (!handle || !resourceTypeName || resourceTypeName[0] == '\0' )
3314     {
3315         OIC_LOG(ERROR, TAG, "Input parameter is NULL");
3316         return OC_STACK_INVALID_PARAM;
3317     }
3318
3319     if (!resourceInterfaceName || strlen(resourceInterfaceName) == 0)
3320     {
3321         resourceInterfaceName = OC_RSRVD_INTERFACE_DEFAULT;
3322     }
3323
3324 #ifdef MQ_PUBLISHER
3325     resourceProperties = resourceProperties | OC_MQ_PUBLISHER;
3326 #endif
3327     // Make sure resourceProperties bitmask has allowed properties specified
3328     if (resourceProperties
3329             > (OC_ACTIVE | OC_DISCOVERABLE | OC_OBSERVABLE | OC_SLOW | OC_SECURE |
3330                OC_EXPLICIT_DISCOVERABLE
3331 #ifdef MQ_PUBLISHER
3332                | OC_MQ_PUBLISHER
3333 #endif
3334 #ifdef MQ_BROKER
3335                | OC_MQ_BROKER
3336 #endif
3337                ))
3338     {
3339         OIC_LOG(ERROR, TAG, "Invalid property");
3340         return OC_STACK_INVALID_PARAM;
3341     }
3342
3343     // If the headResource is NULL, then no resources have been created...
3344     pointer = headResource;
3345     if (pointer)
3346     {
3347         // At least one resources is in the resource list, so we need to search for
3348         // repeated URLs, which are not allowed.  If a repeat is found, exit with an error
3349         while (pointer)
3350         {
3351             if (strncmp(uri, pointer->uri, MAX_URI_LENGTH) == 0)
3352             {
3353                 OIC_LOG_V(ERROR, TAG, "Resource %s already exists", uri);
3354                 return OC_STACK_INVALID_PARAM;
3355             }
3356             pointer = pointer->next;
3357         }
3358     }
3359     // Create the pointer and insert it into the resource list
3360     pointer = (OCResource *) OICCalloc(1, sizeof(OCResource));
3361     if (!pointer)
3362     {
3363         result = OC_STACK_NO_MEMORY;
3364         goto exit;
3365     }
3366     pointer->sequenceNum = OC_OFFSET_SEQUENCE_NUMBER;
3367
3368     insertResource(pointer);
3369
3370     // Set the uri
3371     pointer->uri = OICStrdup(uri);
3372     if (!pointer->uri)
3373     {
3374         result = OC_STACK_NO_MEMORY;
3375         goto exit;
3376     }
3377
3378     // Set properties.  Set OC_ACTIVE
3379     pointer->resourceProperties = (OCResourceProperty) (resourceProperties
3380             | OC_ACTIVE);
3381
3382     // Add the resourcetype to the resource
3383     result = BindResourceTypeToResource(pointer, resourceTypeName);
3384     if (result != OC_STACK_OK)
3385     {
3386         OIC_LOG(ERROR, TAG, "Error adding resourcetype");
3387         goto exit;
3388     }
3389
3390     // Add the resourceinterface to the resource
3391     result = BindResourceInterfaceToResource(pointer, resourceInterfaceName);
3392     if (result != OC_STACK_OK)
3393     {
3394         OIC_LOG(ERROR, TAG, "Error adding resourceinterface");
3395         goto exit;
3396     }
3397
3398     // If an entity handler has been passed, attach it to the newly created
3399     // resource.  Otherwise, set the default entity handler.
3400     if (entityHandler)
3401     {
3402         pointer->entityHandler = entityHandler;
3403         pointer->entityHandlerCallbackParam = callbackParam;
3404     }
3405     else
3406     {
3407         pointer->entityHandler = defaultResourceEHandler;
3408         pointer->entityHandlerCallbackParam = NULL;
3409     }
3410
3411     // Initialize a pointer indicating child resources in case of collection
3412     pointer->rsrcChildResourcesHead = NULL;
3413
3414     *handle = pointer;
3415     result = OC_STACK_OK;
3416
3417 #ifdef WITH_PRESENCE
3418     if (presenceResource.handle)
3419     {
3420         ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
3421         SendPresenceNotification(pointer->rsrcType, OC_PRESENCE_TRIGGER_CREATE);
3422     }
3423 #endif
3424 exit:
3425     if (result != OC_STACK_OK)
3426     {
3427         // Deep delete of resource and other dynamic elements that it contains
3428         deleteResource(pointer);
3429     }
3430     return result;
3431 }
3432
3433 OCStackResult OCBindResource(
3434         OCResourceHandle collectionHandle, OCResourceHandle resourceHandle)
3435 {
3436     OCResource *resource = NULL;
3437     OCChildResource *tempChildResource = NULL;
3438     OCChildResource *newChildResource = NULL;
3439
3440     OIC_LOG(INFO, TAG, "Entering OCBindResource");
3441
3442     // Validate parameters
3443     VERIFY_NON_NULL(collectionHandle, ERROR, OC_STACK_ERROR);
3444     VERIFY_NON_NULL(resourceHandle, ERROR, OC_STACK_ERROR);
3445     // Container cannot contain itself
3446     if (collectionHandle == resourceHandle)
3447     {
3448         OIC_LOG(ERROR, TAG, "Added handle equals collection handle");
3449         return OC_STACK_INVALID_PARAM;
3450     }
3451
3452     // Use the handle to find the resource in the resource linked list
3453     resource = findResource((OCResource *) collectionHandle);
3454     if (!resource)
3455     {
3456         OIC_LOG(ERROR, TAG, "Collection handle not found");
3457         return OC_STACK_INVALID_PARAM;
3458     }
3459
3460     // Look for an open slot to add add the child resource.
3461     // If found, add it and return success
3462
3463     tempChildResource = resource->rsrcChildResourcesHead;
3464
3465     while(resource->rsrcChildResourcesHead && tempChildResource->next)
3466     {
3467         // TODO: what if one of child resource was deregistered without unbinding?
3468         tempChildResource = tempChildResource->next;
3469     }
3470
3471     // Do memory allocation for child resource
3472     newChildResource = (OCChildResource *) OICCalloc(1, sizeof(OCChildResource));
3473     if(!newChildResource)
3474     {
3475         OIC_LOG(ERROR, TAG, "Adding new child resource is failed due to memory allocation failure");
3476         return OC_STACK_ERROR;
3477     }
3478
3479     newChildResource->rsrcResource = (OCResource *) resourceHandle;
3480     newChildResource->next = NULL;
3481
3482     if(!resource->rsrcChildResourcesHead)
3483     {
3484         resource->rsrcChildResourcesHead = newChildResource;
3485     }
3486     else {
3487         tempChildResource->next = newChildResource;
3488     }
3489
3490     OIC_LOG(INFO, TAG, "resource bound");
3491
3492 #ifdef WITH_PRESENCE
3493     if (presenceResource.handle)
3494     {
3495         ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
3496         SendPresenceNotification(((OCResource *) resourceHandle)->rsrcType,
3497                 OC_PRESENCE_TRIGGER_CHANGE);
3498     }
3499 #endif
3500
3501     return OC_STACK_OK;
3502 }
3503
3504 OCStackResult OCUnBindResource(
3505         OCResourceHandle collectionHandle, OCResourceHandle resourceHandle)
3506 {
3507     OCResource *resource = NULL;
3508     OCChildResource *tempChildResource = NULL;
3509     OCChildResource *tempLastChildResource = NULL;
3510
3511     OIC_LOG(INFO, TAG, "Entering OCUnBindResource");
3512
3513     // Validate parameters
3514     VERIFY_NON_NULL(collectionHandle, ERROR, OC_STACK_ERROR);
3515     VERIFY_NON_NULL(resourceHandle, ERROR, OC_STACK_ERROR);
3516     // Container cannot contain itself
3517     if (collectionHandle == resourceHandle)
3518     {
3519         OIC_LOG(ERROR, TAG, "removing handle equals collection handle");
3520         return OC_STACK_INVALID_PARAM;
3521     }
3522
3523     // Use the handle to find the resource in the resource linked list
3524     resource = findResource((OCResource *) collectionHandle);
3525     if (!resource)
3526     {
3527         OIC_LOG(ERROR, TAG, "Collection handle not found");
3528         return OC_STACK_INVALID_PARAM;
3529     }
3530
3531     // Look for an open slot to add add the child resource.
3532     // If found, add it and return success
3533     if(!resource->rsrcChildResourcesHead)
3534     {
3535         OIC_LOG(INFO, TAG, "resource not found in collection");
3536
3537         // Unable to add resourceHandle, so return error
3538         return OC_STACK_ERROR;
3539
3540     }
3541
3542     tempChildResource = resource->rsrcChildResourcesHead;
3543
3544     while (tempChildResource)
3545     {
3546         if(tempChildResource->rsrcResource == resourceHandle)
3547         {
3548             // if resource going to be unbinded is the head one.
3549             if( tempChildResource == resource->rsrcChildResourcesHead )
3550             {
3551                 OCChildResource *temp = resource->rsrcChildResourcesHead->next;
3552                 OICFree(resource->rsrcChildResourcesHead);
3553                 resource->rsrcChildResourcesHead = temp;
3554                 temp = NULL;
3555             }
3556             else
3557             {
3558                 OCChildResource *temp = tempChildResource->next;
3559                 OICFree(tempChildResource);
3560                 tempLastChildResource->next = temp;
3561                 temp = NULL;
3562             }
3563
3564             OIC_LOG(INFO, TAG, "resource unbound");
3565
3566             // Send notification when resource is unbounded successfully.
3567 #ifdef WITH_PRESENCE
3568             if (presenceResource.handle)
3569             {
3570                 ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
3571                 SendPresenceNotification(((OCResource *) resourceHandle)->rsrcType,
3572                         OC_PRESENCE_TRIGGER_CHANGE);
3573             }
3574 #endif
3575             tempChildResource = NULL;
3576             tempLastChildResource = NULL;
3577
3578             return OC_STACK_OK;
3579
3580         }
3581
3582         tempLastChildResource = tempChildResource;
3583         tempChildResource = tempChildResource->next;
3584     }
3585
3586     OIC_LOG(INFO, TAG, "resource not found in collection");
3587
3588     tempChildResource = NULL;
3589     tempLastChildResource = NULL;
3590
3591     // Unable to add resourceHandle, so return error
3592     return OC_STACK_ERROR;
3593 }
3594
3595 static bool ValidateResourceTypeInterface(const char *resourceItemName)
3596 {
3597     if (!resourceItemName)
3598     {
3599         return false;
3600     }
3601     // Per RFC 6690 only registered values must follow the first rule below.
3602     // At this point in time the only values registered begin with "core", and
3603     // all other values are specified as opaque strings where multiple values
3604     // are separated by a space.
3605     if (strncmp(resourceItemName, CORESPEC, sizeof(CORESPEC) - 1) == 0)
3606     {
3607         for(size_t index = sizeof(CORESPEC) - 1;  resourceItemName[index]; ++index)
3608         {
3609             if (resourceItemName[index] != '.'
3610                 && resourceItemName[index] != '-'
3611                 && (resourceItemName[index] < 'a' || resourceItemName[index] > 'z')
3612                 && (resourceItemName[index] < '0' || resourceItemName[index] > '9'))
3613             {
3614                 return false;
3615             }
3616         }
3617     }
3618     else
3619     {
3620         for (size_t index = 0; resourceItemName[index]; ++index)
3621         {
3622             if (resourceItemName[index] == ' '
3623                 || resourceItemName[index] == '\t'
3624                 || resourceItemName[index] == '\r'
3625                 || resourceItemName[index] == '\n')
3626             {
3627                 return false;
3628             }
3629         }
3630     }
3631
3632     return true;
3633 }
3634
3635 OCStackResult BindResourceTypeToResource(OCResource* resource,
3636                                             const char *resourceTypeName)
3637 {
3638     OCResourceType *pointer = NULL;
3639     char *str = NULL;
3640     OCStackResult result = OC_STACK_ERROR;
3641
3642     VERIFY_NON_NULL(resourceTypeName, ERROR, OC_STACK_INVALID_PARAM);
3643
3644     if (!ValidateResourceTypeInterface(resourceTypeName))
3645     {
3646         OIC_LOG(ERROR, TAG, "resource type illegal (see RFC 6690)");
3647         return OC_STACK_INVALID_PARAM;
3648     }
3649
3650     pointer = (OCResourceType *) OICCalloc(1, sizeof(OCResourceType));
3651     if (!pointer)
3652     {
3653         result = OC_STACK_NO_MEMORY;
3654         goto exit;
3655     }
3656
3657     str = OICStrdup(resourceTypeName);
3658     if (!str)
3659     {
3660         result = OC_STACK_NO_MEMORY;
3661         goto exit;
3662     }
3663     pointer->resourcetypename = str;
3664     pointer->next = NULL;
3665
3666     insertResourceType(resource, pointer);
3667     result = OC_STACK_OK;
3668
3669 exit:
3670     if (result != OC_STACK_OK)
3671     {
3672         OICFree(pointer);
3673         OICFree(str);
3674     }
3675
3676     return result;
3677 }
3678
3679 OCStackResult BindResourceInterfaceToResource(OCResource* resource,
3680         const char *resourceInterfaceName)
3681 {
3682     OCResourceInterface *pointer = NULL;
3683     char *str = NULL;
3684     OCStackResult result = OC_STACK_ERROR;
3685
3686     VERIFY_NON_NULL(resourceInterfaceName, ERROR, OC_STACK_INVALID_PARAM);
3687
3688     if (!ValidateResourceTypeInterface(resourceInterfaceName))
3689     {
3690         OIC_LOG(ERROR, TAG, "resource /interface illegal (see RFC 6690)");
3691         return OC_STACK_INVALID_PARAM;
3692     }
3693
3694     OIC_LOG_V(INFO, TAG, "Binding %s interface to %s", resourceInterfaceName, resource->uri);
3695
3696     pointer = (OCResourceInterface *) OICCalloc(1, sizeof(OCResourceInterface));
3697     if (!pointer)
3698     {
3699         result = OC_STACK_NO_MEMORY;
3700         goto exit;
3701     }
3702
3703     str = OICStrdup(resourceInterfaceName);
3704     if (!str)
3705     {
3706         result = OC_STACK_NO_MEMORY;
3707         goto exit;
3708     }
3709     pointer->name = str;
3710
3711     // Bind the resourceinterface to the resource
3712     insertResourceInterface(resource, pointer);
3713
3714     result = OC_STACK_OK;
3715
3716     exit:
3717     if (result != OC_STACK_OK)
3718     {
3719         OICFree(pointer);
3720         OICFree(str);
3721     }
3722
3723     return result;
3724 }
3725
3726 OCStackResult OCBindResourceTypeToResource(OCResourceHandle handle,
3727         const char *resourceTypeName)
3728 {
3729
3730     OCStackResult result = OC_STACK_ERROR;
3731     OCResource *resource = NULL;
3732
3733     resource = findResource((OCResource *) handle);
3734     if (!resource)
3735     {
3736         OIC_LOG(ERROR, TAG, "Resource not found");
3737         return OC_STACK_ERROR;
3738     }
3739
3740     result = BindResourceTypeToResource(resource, resourceTypeName);
3741
3742 #ifdef WITH_PRESENCE
3743     if(presenceResource.handle)
3744     {
3745         ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
3746         SendPresenceNotification(resource->rsrcType, OC_PRESENCE_TRIGGER_CHANGE);
3747     }
3748 #endif
3749
3750     return result;
3751 }
3752
3753 OCStackResult OCBindResourceInterfaceToResource(OCResourceHandle handle,
3754         const char *resourceInterfaceName)
3755 {
3756
3757     OCStackResult result = OC_STACK_ERROR;
3758     OCResource *resource = NULL;
3759
3760     resource = findResource((OCResource *) handle);
3761     if (!resource)
3762     {
3763         OIC_LOG(ERROR, TAG, "Resource not found");
3764         return OC_STACK_ERROR;
3765     }
3766
3767     result = BindResourceInterfaceToResource(resource, resourceInterfaceName);
3768
3769 #ifdef WITH_PRESENCE
3770     if (presenceResource.handle)
3771     {
3772         ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
3773         SendPresenceNotification(resource->rsrcType, OC_PRESENCE_TRIGGER_CHANGE);
3774     }
3775 #endif
3776
3777     return result;
3778 }
3779
3780 OCStackResult OCGetNumberOfResources(uint8_t *numResources)
3781 {
3782     OCResource *pointer = headResource;
3783
3784     VERIFY_NON_NULL(numResources, ERROR, OC_STACK_INVALID_PARAM);
3785     *numResources = 0;
3786     while (pointer)
3787     {
3788         *numResources = *numResources + 1;
3789         pointer = pointer->next;
3790     }
3791     return OC_STACK_OK;
3792 }
3793
3794 OCResourceHandle OCGetResourceHandle(uint8_t index)
3795 {
3796     OCResource *pointer = headResource;
3797
3798     for( uint8_t i = 0; i < index && pointer; ++i)
3799     {
3800         pointer = pointer->next;
3801     }
3802     return (OCResourceHandle) pointer;
3803 }
3804
3805 OCStackResult OCDeleteResource(OCResourceHandle handle)
3806 {
3807     if (!handle)
3808     {
3809         OIC_LOG(ERROR, TAG, "Invalid handle for deletion");
3810         return OC_STACK_INVALID_PARAM;
3811     }
3812
3813     OCResource *resource = findResource((OCResource *) handle);
3814     if (resource == NULL)
3815     {
3816         OIC_LOG(ERROR, TAG, "Resource not found");
3817         return OC_STACK_NO_RESOURCE;
3818     }
3819
3820     if (deleteResource((OCResource *) handle) != OC_STACK_OK)
3821     {
3822         OIC_LOG(ERROR, TAG, "Error deleting resource");
3823         return OC_STACK_ERROR;
3824     }
3825
3826     return OC_STACK_OK;
3827 }
3828
3829 const char *OCGetResourceUri(OCResourceHandle handle)
3830 {
3831     OCResource *resource = NULL;
3832
3833     resource = findResource((OCResource *) handle);
3834     if (resource)
3835     {
3836         return resource->uri;
3837     }
3838     return (const char *) NULL;
3839 }
3840
3841 OCResourceProperty OCGetResourceProperties(OCResourceHandle handle)
3842 {
3843     OCResource *resource = NULL;
3844
3845     resource = findResource((OCResource *) handle);
3846     if (resource)
3847     {
3848         return resource->resourceProperties;
3849     }
3850     return (OCResourceProperty)-1;
3851 }
3852
3853 OCStackResult OCGetNumberOfResourceTypes(OCResourceHandle handle,
3854         uint8_t *numResourceTypes)
3855 {
3856     OCResource *resource = NULL;
3857     OCResourceType *pointer = NULL;
3858
3859     VERIFY_NON_NULL(numResourceTypes, ERROR, OC_STACK_INVALID_PARAM);
3860     VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
3861
3862     *numResourceTypes = 0;
3863
3864     resource = findResource((OCResource *) handle);
3865     if (resource)
3866     {
3867         pointer = resource->rsrcType;
3868         while (pointer)
3869         {
3870             *numResourceTypes = *numResourceTypes + 1;
3871             pointer = pointer->next;
3872         }
3873     }
3874     return OC_STACK_OK;
3875 }
3876
3877 const char *OCGetResourceTypeName(OCResourceHandle handle, uint8_t index)
3878 {
3879     OCResourceType *resourceType = NULL;
3880
3881     resourceType = findResourceTypeAtIndex(handle, index);
3882     if (resourceType)
3883     {
3884         return resourceType->resourcetypename;
3885     }
3886     return (const char *) NULL;
3887 }
3888
3889 OCStackResult OCGetNumberOfResourceInterfaces(OCResourceHandle handle,
3890         uint8_t *numResourceInterfaces)
3891 {
3892     OCResourceInterface *pointer = NULL;
3893     OCResource *resource = NULL;
3894
3895     VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
3896     VERIFY_NON_NULL(numResourceInterfaces, ERROR, OC_STACK_INVALID_PARAM);
3897
3898     *numResourceInterfaces = 0;
3899     resource = findResource((OCResource *) handle);
3900     if (resource)
3901     {
3902         pointer = resource->rsrcInterface;
3903         while (pointer)
3904         {
3905             *numResourceInterfaces = *numResourceInterfaces + 1;
3906             pointer = pointer->next;
3907         }
3908     }
3909     return OC_STACK_OK;
3910 }
3911
3912 const char *OCGetResourceInterfaceName(OCResourceHandle handle, uint8_t index)
3913 {
3914     OCResourceInterface *resourceInterface = NULL;
3915
3916     resourceInterface = findResourceInterfaceAtIndex(handle, index);
3917     if (resourceInterface)
3918     {
3919         return resourceInterface->name;
3920     }
3921     return (const char *) NULL;
3922 }
3923
3924 OCResourceHandle OCGetResourceHandleFromCollection(OCResourceHandle collectionHandle,
3925         uint8_t index)
3926 {
3927     OCResource *resource = NULL;
3928     OCChildResource *tempChildResource = NULL;
3929     uint8_t num = 0;
3930
3931     resource = findResource((OCResource *) collectionHandle);
3932     if (!resource)
3933     {
3934         return NULL;
3935     }
3936
3937     tempChildResource = resource->rsrcChildResourcesHead;
3938
3939     while(tempChildResource)
3940     {
3941         if( num == index )
3942         {
3943             return tempChildResource->rsrcResource;
3944         }
3945         num++;
3946         tempChildResource = tempChildResource->next;
3947     }
3948
3949     // In this case, the number of resource handles in the collection exceeds the index
3950     tempChildResource = NULL;
3951     return NULL;
3952 }
3953
3954 OCStackResult OCBindResourceHandler(OCResourceHandle handle,
3955         OCEntityHandler entityHandler,
3956         void* callbackParam)
3957 {
3958     OCResource *resource = NULL;
3959
3960     // Validate parameters
3961     VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
3962
3963     // Use the handle to find the resource in the resource linked list
3964     resource = findResource((OCResource *)handle);
3965     if (!resource)
3966     {
3967         OIC_LOG(ERROR, TAG, "Resource not found");
3968         return OC_STACK_ERROR;
3969     }
3970
3971     // Bind the handler
3972     resource->entityHandler = entityHandler;
3973     resource->entityHandlerCallbackParam = callbackParam;
3974
3975 #ifdef WITH_PRESENCE
3976     if (presenceResource.handle)
3977     {
3978         ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
3979         SendPresenceNotification(resource->rsrcType, OC_PRESENCE_TRIGGER_CHANGE);
3980     }
3981 #endif
3982
3983     return OC_STACK_OK;
3984 }
3985
3986 OCEntityHandler OCGetResourceHandler(OCResourceHandle handle)
3987 {
3988     OCResource *resource = NULL;
3989
3990     resource = findResource((OCResource *)handle);
3991     if (!resource)
3992     {
3993         OIC_LOG(ERROR, TAG, "Resource not found");
3994         return NULL;
3995     }
3996
3997     // Bind the handler
3998     return resource->entityHandler;
3999 }
4000
4001 void incrementSequenceNumber(OCResource * resPtr)
4002 {
4003     // Increment the sequence number
4004     resPtr->sequenceNum += 1;
4005     if (resPtr->sequenceNum == MAX_SEQUENCE_NUMBER)
4006     {
4007         resPtr->sequenceNum = OC_OFFSET_SEQUENCE_NUMBER+1;
4008     }
4009     return;
4010 }
4011
4012 #ifdef WITH_PRESENCE
4013 OCStackResult SendPresenceNotification(OCResourceType *resourceType,
4014         OCPresenceTrigger trigger)
4015 {
4016     OCResource *resPtr = NULL;
4017     OCStackResult result = OC_STACK_ERROR;
4018     OCMethod method = OC_REST_PRESENCE;
4019     uint32_t maxAge = 0;
4020     resPtr = findResource((OCResource *) presenceResource.handle);
4021     if(NULL == resPtr)
4022     {
4023         return OC_STACK_NO_RESOURCE;
4024     }
4025
4026     if((((OCResource *) presenceResource.handle)->resourceProperties) & OC_ACTIVE)
4027     {
4028         maxAge = presenceResource.presenceTTL;
4029
4030         result = SendAllObserverNotification(method, resPtr, maxAge,
4031                 trigger, resourceType, OC_LOW_QOS);
4032     }
4033
4034     return result;
4035 }
4036
4037 OCStackResult SendStopNotification()
4038 {
4039     OCResource *resPtr = NULL;
4040     OCStackResult result = OC_STACK_ERROR;
4041     OCMethod method = OC_REST_PRESENCE;
4042     resPtr = findResource((OCResource *) presenceResource.handle);
4043     if(NULL == resPtr)
4044     {
4045         return OC_STACK_NO_RESOURCE;
4046     }
4047
4048     // maxAge is 0. ResourceType is NULL.
4049     result = SendAllObserverNotification(method, resPtr, 0, OC_PRESENCE_TRIGGER_DELETE,
4050             NULL, OC_LOW_QOS);
4051
4052     return result;
4053 }
4054
4055 #endif // WITH_PRESENCE
4056 OCStackResult OCNotifyAllObservers(OCResourceHandle handle, OCQualityOfService qos)
4057 {
4058     OCResource *resPtr = NULL;
4059     OCStackResult result = OC_STACK_ERROR;
4060     OCMethod method = OC_REST_NOMETHOD;
4061     uint32_t maxAge = 0;
4062
4063     OIC_LOG(INFO, TAG, "Notifying all observers");
4064 #ifdef WITH_PRESENCE
4065     if(handle == presenceResource.handle)
4066     {
4067         return OC_STACK_OK;
4068     }
4069 #endif // WITH_PRESENCE
4070     VERIFY_NON_NULL(handle, ERROR, OC_STACK_ERROR);
4071
4072     // Verify that the resource exists
4073     resPtr = findResource ((OCResource *) handle);
4074     if (NULL == resPtr)
4075     {
4076         return OC_STACK_NO_RESOURCE;
4077     }
4078     else
4079     {
4080         //only increment in the case of regular observing (not presence)
4081         incrementSequenceNumber(resPtr);
4082         method = OC_REST_OBSERVE;
4083         maxAge = MAX_OBSERVE_AGE;
4084 #ifdef WITH_PRESENCE
4085         result = SendAllObserverNotification (method, resPtr, maxAge,
4086                 OC_PRESENCE_TRIGGER_DELETE, NULL, qos);
4087 #else
4088         result = SendAllObserverNotification (method, resPtr, maxAge, qos);
4089 #endif
4090         return result;
4091     }
4092 }
4093
4094 OCStackResult
4095 OCNotifyListOfObservers (OCResourceHandle handle,
4096                          OCObservationId  *obsIdList,
4097                          uint8_t          numberOfIds,
4098                          const OCRepPayload       *payload,
4099                          OCQualityOfService qos)
4100 {
4101     OIC_LOG(INFO, TAG, "Entering OCNotifyListOfObservers");
4102
4103     OCResource *resPtr = NULL;
4104     //TODO: we should allow the server to define this
4105     uint32_t maxAge = MAX_OBSERVE_AGE;
4106
4107     VERIFY_NON_NULL(handle, ERROR, OC_STACK_ERROR);
4108     VERIFY_NON_NULL(obsIdList, ERROR, OC_STACK_ERROR);
4109     VERIFY_NON_NULL(payload, ERROR, OC_STACK_ERROR);
4110
4111     resPtr = findResource ((OCResource *) handle);
4112     if (NULL == resPtr || myStackMode == OC_CLIENT)
4113     {
4114         return OC_STACK_NO_RESOURCE;
4115     }
4116     else
4117     {
4118         incrementSequenceNumber(resPtr);
4119     }
4120     return (SendListObserverNotification(resPtr, obsIdList, numberOfIds,
4121             payload, maxAge, qos));
4122 }
4123
4124 OCStackResult OCDoResponse(OCEntityHandlerResponse *ehResponse)
4125 {
4126     OCStackResult result = OC_STACK_ERROR;
4127     OCServerRequest *serverRequest = NULL;
4128
4129     OIC_LOG(INFO, TAG, "Entering OCDoResponse");
4130
4131     // Validate input parameters
4132     VERIFY_NON_NULL(ehResponse, ERROR, OC_STACK_INVALID_PARAM);
4133     VERIFY_NON_NULL(ehResponse->requestHandle, ERROR, OC_STACK_INVALID_PARAM);
4134
4135     // Normal response
4136     // Get pointer to request info
4137     serverRequest = GetServerRequestUsingHandle((OCServerRequest *)ehResponse->requestHandle);
4138     if(serverRequest)
4139     {
4140         // response handler in ocserverrequest.c. Usually HandleSingleResponse.
4141         result = serverRequest->ehResponseHandler(ehResponse);
4142     }
4143
4144     return result;
4145 }
4146
4147 //#ifdef DIRECT_PAIRING
4148 const OCDPDev_t* OCDiscoverDirectPairingDevices(unsigned short waittime)
4149 {
4150     OIC_LOG(INFO, TAG, "Start OCDiscoverDirectPairingDevices");
4151     if(OC_STACK_OK != DPDeviceDiscovery(waittime))
4152     {
4153         OIC_LOG(ERROR, TAG, "Fail to discover Direct-Pairing device");
4154         return NULL;
4155     }
4156
4157     return (const OCDPDev_t*)DPGetDiscoveredDevices();
4158 }
4159
4160 const OCDPDev_t* OCGetDirectPairedDevices()
4161 {
4162     return (const OCDPDev_t*)DPGetPairedDevices();
4163 }
4164
4165 OCStackResult OCDoDirectPairing(void *ctx, OCDPDev_t* peer, OCPrm_t pmSel, char *pinNumber,
4166                                                      OCDirectPairingCB resultCallback)
4167 {
4168     OIC_LOG(INFO, TAG, "Start OCDoDirectPairing");
4169     if(NULL ==  peer || NULL == pinNumber)
4170     {
4171         OIC_LOG(ERROR, TAG, "Invalid parameters");
4172         return OC_STACK_INVALID_PARAM;
4173     }
4174     if (NULL == resultCallback)
4175     {
4176         OIC_LOG(ERROR, TAG, "Invalid callback");
4177         return OC_STACK_INVALID_CALLBACK;
4178     }
4179
4180     return DPDirectPairing(ctx, (OCDirectPairingDev_t*)peer, (OicSecPrm_t)pmSel,
4181                                            pinNumber, (OCDirectPairingResultCB)resultCallback);
4182 }
4183 //#endif // DIRECT_PAIRING
4184
4185 //-----------------------------------------------------------------------------
4186 // Private internal function definitions
4187 //-----------------------------------------------------------------------------
4188 static OCDoHandle GenerateInvocationHandle()
4189 {
4190     OCDoHandle handle = NULL;
4191     // Generate token here, it will be deleted when the transaction is deleted
4192     handle = (OCDoHandle) OICMalloc(sizeof(uint8_t[CA_MAX_TOKEN_LEN]));
4193     if (handle)
4194     {
4195         OCFillRandomMem((uint8_t*)handle, sizeof(uint8_t[CA_MAX_TOKEN_LEN]));
4196     }
4197
4198     return handle;
4199 }
4200
4201 #ifdef WITH_PRESENCE
4202 OCStackResult OCChangeResourceProperty(OCResourceProperty * inputProperty,
4203         OCResourceProperty resourceProperties, uint8_t enable)
4204 {
4205     if (!inputProperty)
4206     {
4207         return OC_STACK_INVALID_PARAM;
4208     }
4209     if (resourceProperties
4210             > (OC_ACTIVE | OC_DISCOVERABLE | OC_OBSERVABLE | OC_SLOW))
4211     {
4212         OIC_LOG(ERROR, TAG, "Invalid property");
4213         return OC_STACK_INVALID_PARAM;
4214     }
4215     if(!enable)
4216     {
4217         *inputProperty = (OCResourceProperty) (*inputProperty & ~(resourceProperties));
4218     }
4219     else
4220     {
4221         *inputProperty = (OCResourceProperty) (*inputProperty | resourceProperties);
4222     }
4223     return OC_STACK_OK;
4224 }
4225 #endif
4226
4227 OCStackResult initResources()
4228 {
4229     OCStackResult result = OC_STACK_OK;
4230
4231     headResource = NULL;
4232     tailResource = NULL;
4233     // Init Virtual Resources
4234 #ifdef WITH_PRESENCE
4235     presenceResource.presenceTTL = OC_DEFAULT_PRESENCE_TTL_SECONDS;
4236
4237     result = OCCreateResource(&presenceResource.handle,
4238             OC_RSRVD_RESOURCE_TYPE_PRESENCE,
4239             "core.r",
4240             OC_RSRVD_PRESENCE_URI,
4241             NULL,
4242             NULL,
4243             OC_OBSERVABLE);
4244     //make resource inactive
4245     result = OCChangeResourceProperty(
4246             &(((OCResource *) presenceResource.handle)->resourceProperties),
4247             OC_ACTIVE, 0);
4248 #endif
4249 #ifndef WITH_ARDUINO
4250     if (result == OC_STACK_OK)
4251     {
4252         result = SRMInitSecureResources();
4253     }
4254 #endif
4255
4256     if(result == OC_STACK_OK)
4257     {
4258         CreateResetProfile();
4259         result = OCCreateResource(&deviceResource,
4260                                   OC_RSRVD_RESOURCE_TYPE_DEVICE,
4261                                   OC_RSRVD_INTERFACE_DEFAULT,
4262                                   OC_RSRVD_DEVICE_URI,
4263                                   NULL,
4264                                   NULL,
4265                                   OC_DISCOVERABLE);
4266         if(result == OC_STACK_OK)
4267         {
4268             result = BindResourceInterfaceToResource((OCResource *)deviceResource,
4269                                                      OC_RSRVD_INTERFACE_READ);
4270         }
4271     }
4272
4273     if(result == OC_STACK_OK)
4274     {
4275         result = OCCreateResource(&platformResource,
4276                                   OC_RSRVD_RESOURCE_TYPE_PLATFORM,
4277                                   OC_RSRVD_INTERFACE_DEFAULT,
4278                                   OC_RSRVD_PLATFORM_URI,
4279                                   NULL,
4280                                   NULL,
4281                                   OC_DISCOVERABLE);
4282         if(result == OC_STACK_OK)
4283         {
4284             result = BindResourceInterfaceToResource((OCResource *)platformResource,
4285                                                      OC_RSRVD_INTERFACE_READ);
4286         }
4287     }
4288
4289     return result;
4290 }
4291
4292 void insertResource(OCResource *resource)
4293 {
4294     if (!headResource)
4295     {
4296         headResource = resource;
4297         tailResource = resource;
4298     }
4299     else
4300     {
4301         tailResource->next = resource;
4302         tailResource = resource;
4303     }
4304     resource->next = NULL;
4305 }
4306
4307 OCResource *findResource(OCResource *resource)
4308 {
4309     OCResource *pointer = headResource;
4310
4311     while (pointer)
4312     {
4313         if (pointer == resource)
4314         {
4315             return resource;
4316         }
4317         pointer = pointer->next;
4318     }
4319     return NULL;
4320 }
4321
4322 void deleteAllResources()
4323 {
4324     OCResource *pointer = headResource;
4325     OCResource *temp = NULL;
4326
4327     while (pointer)
4328     {
4329         temp = pointer->next;
4330 #ifdef WITH_PRESENCE
4331         if (pointer != (OCResource *) presenceResource.handle)
4332         {
4333 #endif // WITH_PRESENCE
4334             deleteResource(pointer);
4335 #ifdef WITH_PRESENCE
4336         }
4337 #endif // WITH_PRESENCE
4338         pointer = temp;
4339     }
4340     memset(&platformResource, 0, sizeof(platformResource));
4341     memset(&deviceResource, 0, sizeof(deviceResource));
4342 #ifdef MQ_BROKER
4343     memset(&brokerResource, 0, sizeof(brokerResource));
4344 #endif
4345
4346     SRMDeInitSecureResources();
4347
4348 #ifdef WITH_PRESENCE
4349     // Ensure that the last resource to be deleted is the presence resource. This allows for all
4350     // presence notification attributed to their deletion to be processed.
4351     deleteResource((OCResource *) presenceResource.handle);
4352     memset(&presenceResource, 0, sizeof(presenceResource));
4353 #endif // WITH_PRESENCE
4354 }
4355
4356 OCStackResult deleteResource(OCResource *resource)
4357 {
4358     OCResource *prev = NULL;
4359     OCResource *temp = NULL;
4360     if(!resource)
4361     {
4362         OIC_LOG(DEBUG,TAG,"resource is NULL");
4363         return OC_STACK_INVALID_PARAM;
4364     }
4365
4366     OIC_LOG_V (INFO, TAG, "Deleting resource %s", resource->uri);
4367
4368     temp = headResource;
4369     while (temp)
4370     {
4371         if (temp == resource)
4372         {
4373             // Invalidate all Resource Properties.
4374             resource->resourceProperties = (OCResourceProperty) 0;
4375 #ifdef WITH_PRESENCE
4376             if(resource != (OCResource *) presenceResource.handle)
4377             {
4378 #endif // WITH_PRESENCE
4379                 OCNotifyAllObservers((OCResourceHandle)resource, OC_HIGH_QOS);
4380 #ifdef WITH_PRESENCE
4381             }
4382
4383             if(presenceResource.handle)
4384             {
4385                 ((OCResource *)presenceResource.handle)->sequenceNum = OCGetRandom();
4386                 SendPresenceNotification(resource->rsrcType, OC_PRESENCE_TRIGGER_DELETE);
4387             }
4388 #endif
4389             // Only resource in list.
4390             if (temp == headResource && temp == tailResource)
4391             {
4392                 headResource = NULL;
4393                 tailResource = NULL;
4394             }
4395             // Deleting head.
4396             else if (temp == headResource)
4397             {
4398                 headResource = temp->next;
4399             }
4400             // Deleting tail.
4401             else if (temp == tailResource)
4402             {
4403                 tailResource = prev;
4404                 tailResource->next = NULL;
4405             }
4406             else
4407             {
4408                 prev->next = temp->next;
4409             }
4410
4411             deleteResourceElements(temp);
4412             OICFree(temp);
4413             return OC_STACK_OK;
4414         }
4415         else
4416         {
4417             prev = temp;
4418             temp = temp->next;
4419         }
4420     }
4421
4422     return OC_STACK_ERROR;
4423 }
4424
4425 void deleteResourceElements(OCResource *resource)
4426 {
4427     if (!resource)
4428     {
4429         return;
4430     }
4431
4432     OICFree(resource->uri);
4433     deleteResourceType(resource->rsrcType);
4434     deleteResourceInterface(resource->rsrcInterface);
4435 }
4436
4437 void deleteResourceType(OCResourceType *resourceType)
4438 {
4439     OCResourceType *pointer = resourceType;
4440     OCResourceType *next = NULL;
4441
4442     while (pointer)
4443     {
4444         next = pointer->next;
4445         OICFree(pointer->resourcetypename);
4446         OICFree(pointer);
4447         pointer = next;
4448     }
4449 }
4450
4451 void deleteResourceInterface(OCResourceInterface *resourceInterface)
4452 {
4453     OCResourceInterface *pointer = resourceInterface;
4454     OCResourceInterface *next = NULL;
4455
4456     while (pointer)
4457     {
4458         next = pointer->next;
4459         OICFree(pointer->name);
4460         OICFree(pointer);
4461         pointer = next;
4462     }
4463 }
4464
4465 void insertResourceType(OCResource *resource, OCResourceType *resourceType)
4466 {
4467     OCResourceType *pointer = NULL;
4468     OCResourceType *previous = NULL;
4469     if (!resource || !resourceType)
4470     {
4471         return;
4472     }
4473     // resource type list is empty.
4474     else if (!resource->rsrcType)
4475     {
4476         resource->rsrcType = resourceType;
4477     }
4478     else
4479     {
4480         pointer = resource->rsrcType;
4481
4482         while (pointer)
4483         {
4484             if (!strcmp(resourceType->resourcetypename, pointer->resourcetypename))
4485             {
4486                 OIC_LOG_V(INFO, TAG, "Type %s already exists", resourceType->resourcetypename);
4487                 OICFree(resourceType->resourcetypename);
4488                 OICFree(resourceType);
4489                 return;
4490             }
4491             previous = pointer;
4492             pointer = pointer->next;
4493         }
4494
4495         if (previous)
4496         {
4497             previous->next = resourceType;
4498         }
4499     }
4500     resourceType->next = NULL;
4501
4502     OIC_LOG_V(INFO, TAG, "Added type %s to %s", resourceType->resourcetypename, resource->uri);
4503 }
4504
4505 OCResourceType *findResourceTypeAtIndex(OCResourceHandle handle, uint8_t index)
4506 {
4507     OCResource *resource = NULL;
4508     OCResourceType *pointer = NULL;
4509
4510     // Find the specified resource
4511     resource = findResource((OCResource *) handle);
4512     if (!resource)
4513     {
4514         return NULL;
4515     }
4516
4517     // Make sure a resource has a resourcetype
4518     if (!resource->rsrcType)
4519     {
4520         return NULL;
4521     }
4522
4523     // Iterate through the list
4524     pointer = resource->rsrcType;
4525     for(uint8_t i = 0; i< index && pointer; ++i)
4526     {
4527         pointer = pointer->next;
4528     }
4529     return pointer;
4530 }
4531
4532 OCResourceType *findResourceType(OCResourceType * resourceTypeList, const char * resourceTypeName)
4533 {
4534     if(resourceTypeList && resourceTypeName)
4535     {
4536         OCResourceType * rtPointer = resourceTypeList;
4537         while(resourceTypeName && rtPointer)
4538         {
4539             OIC_LOG_V(DEBUG, TAG, "current resourceType : %s", rtPointer->resourcetypename);
4540             if(rtPointer->resourcetypename &&
4541                     strcmp(resourceTypeName, (const char *)
4542                     (rtPointer->resourcetypename)) == 0)
4543             {
4544                 break;
4545             }
4546             rtPointer = rtPointer->next;
4547         }
4548         return rtPointer;
4549     }
4550     return NULL;
4551 }
4552
4553 /*
4554  * Insert a new interface into interface linked list only if not already present.
4555  * If alredy present, 2nd arg is free'd.
4556  * Default interface will always be first if present.
4557  */
4558 void insertResourceInterface(OCResource *resource, OCResourceInterface *newInterface)
4559 {
4560     OCResourceInterface *pointer = NULL;
4561     OCResourceInterface *previous = NULL;
4562
4563     newInterface->next = NULL;
4564
4565     OCResourceInterface **firstInterface = &(resource->rsrcInterface);
4566
4567     if (!*firstInterface)
4568     {
4569         // If first interface is not oic.if.baseline, by default add it as first interface type.
4570         if (0 == strcmp(newInterface->name, OC_RSRVD_INTERFACE_DEFAULT))
4571         {
4572             *firstInterface = newInterface;
4573         }
4574         else
4575         {
4576             OCStackResult result = BindResourceInterfaceToResource(resource,
4577                                                                     OC_RSRVD_INTERFACE_DEFAULT);
4578             if (result != OC_STACK_OK)
4579             {
4580                 OICFree(newInterface->name);
4581                 OICFree(newInterface);
4582                 return;
4583             }
4584             if (*firstInterface)
4585             {
4586                 (*firstInterface)->next = newInterface;
4587             }
4588         }
4589     }
4590     // If once add oic.if.baseline, later too below code take care of freeing memory.
4591     else if (strcmp(newInterface->name, OC_RSRVD_INTERFACE_DEFAULT) == 0)
4592     {
4593         if (strcmp((*firstInterface)->name, OC_RSRVD_INTERFACE_DEFAULT) == 0)
4594         {
4595             OICFree(newInterface->name);
4596             OICFree(newInterface);
4597             return;
4598         }
4599         // This code will not hit anymore, keeping
4600         else
4601         {
4602             newInterface->next = *firstInterface;
4603             *firstInterface = newInterface;
4604         }
4605     }
4606     else
4607     {
4608         pointer = *firstInterface;
4609         while (pointer)
4610         {
4611             if (strcmp(newInterface->name, pointer->name) == 0)
4612             {
4613                 OICFree(newInterface->name);
4614                 OICFree(newInterface);
4615                 return;
4616             }
4617             previous = pointer;
4618             pointer = pointer->next;
4619         }
4620
4621         if (previous)
4622         {
4623             previous->next = newInterface;
4624         }
4625     }
4626 }
4627
4628 OCResourceInterface *findResourceInterfaceAtIndex(OCResourceHandle handle,
4629         uint8_t index)
4630 {
4631     OCResource *resource = NULL;
4632     OCResourceInterface *pointer = NULL;
4633
4634     // Find the specified resource
4635     resource = findResource((OCResource *) handle);
4636     if (!resource)
4637     {
4638         return NULL;
4639     }
4640
4641     // Make sure a resource has a resourceinterface
4642     if (!resource->rsrcInterface)
4643     {
4644         return NULL;
4645     }
4646
4647     // Iterate through the list
4648     pointer = resource->rsrcInterface;
4649
4650     for (uint8_t i = 0; i < index && pointer; ++i)
4651     {
4652         pointer = pointer->next;
4653     }
4654     return pointer;
4655 }
4656
4657 /*
4658  * This function splits the uri using the '?' delimiter.
4659  * "uriWithoutQuery" is the block of characters between the beginning
4660  * till the delimiter or '\0' which ever comes first.
4661  * "query" is whatever is to the right of the delimiter if present.
4662  * No delimiter sets the query to NULL.
4663  * If either are present, they will be malloc'ed into the params 2, 3.
4664  * The first param, *uri is left untouched.
4665
4666  * NOTE: This function does not account for whitespace at the end of the uri NOR
4667  *       malformed uri's with '??'. Whitespace at the end will be assumed to be
4668  *       part of the query.
4669  */
4670 OCStackResult getQueryFromUri(const char * uri, char** query, char ** uriWithoutQuery)
4671 {
4672     if(!uri)
4673     {
4674         return OC_STACK_INVALID_URI;
4675     }
4676     if(!query || !uriWithoutQuery)
4677     {
4678         return OC_STACK_INVALID_PARAM;
4679     }
4680
4681     *query           = NULL;
4682     *uriWithoutQuery = NULL;
4683
4684     size_t uriWithoutQueryLen = 0;
4685     size_t queryLen = 0;
4686     size_t uriLen = strlen(uri);
4687
4688     char *pointerToDelimiter = strstr(uri, "?");
4689
4690     uriWithoutQueryLen = pointerToDelimiter == NULL ? uriLen : (size_t)(pointerToDelimiter - uri);
4691     queryLen = pointerToDelimiter == NULL ? 0 : uriLen - uriWithoutQueryLen - 1;
4692
4693     if (uriWithoutQueryLen)
4694     {
4695         *uriWithoutQuery =  (char *) OICCalloc(uriWithoutQueryLen + 1, 1);
4696         if (!*uriWithoutQuery)
4697         {
4698             goto exit;
4699         }
4700         OICStrcpy(*uriWithoutQuery, uriWithoutQueryLen +1, uri);
4701     }
4702     if (queryLen)
4703     {
4704         *query = (char *) OICCalloc(queryLen + 1, 1);
4705         if (!*query)
4706         {
4707             OICFree(*uriWithoutQuery);
4708             *uriWithoutQuery = NULL;
4709             goto exit;
4710         }
4711         OICStrcpy(*query, queryLen + 1, pointerToDelimiter + 1);
4712     }
4713
4714     return OC_STACK_OK;
4715
4716     exit:
4717         return OC_STACK_NO_MEMORY;
4718 }
4719
4720 static const OicUuid_t* OCGetServerInstanceID(void)
4721 {
4722     static bool generated = false;
4723     static OicUuid_t sid;
4724     if (generated)
4725     {
4726         return &sid;
4727     }
4728
4729     if (OC_STACK_OK != GetDoxmDeviceID(&sid))
4730     {
4731         OIC_LOG(FATAL, TAG, "Generate UUID for Server Instance failed!");
4732         return NULL;
4733     }
4734     generated = true;
4735     return &sid;
4736 }
4737
4738 const char* OCGetServerInstanceIDString(void)
4739 {
4740     static bool generated = false;
4741     static char sidStr[UUID_STRING_SIZE];
4742
4743     if(generated)
4744     {
4745         return sidStr;
4746     }
4747
4748     const OicUuid_t *sid = OCGetServerInstanceID();
4749     if(OCConvertUuidToString(sid->id, sidStr) != RAND_UUID_OK)
4750     {
4751         OIC_LOG(FATAL, TAG, "Generate UUID String for Server Instance failed!");
4752         return NULL;
4753     }
4754
4755     generated = true;
4756     return sidStr;
4757 }
4758
4759 CAResult_t OCSelectNetwork()
4760 {
4761     CAResult_t retResult = CA_STATUS_FAILED;
4762     CAResult_t caResult = CA_STATUS_OK;
4763
4764     CATransportAdapter_t connTypes[] = {
4765             CA_ADAPTER_IP,
4766             CA_ADAPTER_RFCOMM_BTEDR,
4767             CA_ADAPTER_GATT_BTLE,
4768             CA_ADAPTER_NFC
4769 #ifdef RA_ADAPTER
4770             ,CA_ADAPTER_REMOTE_ACCESS
4771 #endif
4772
4773 #ifdef TCP_ADAPTER
4774             ,CA_ADAPTER_TCP
4775 #endif
4776         };
4777     int numConnTypes = sizeof(connTypes)/sizeof(connTypes[0]);
4778
4779     for(int i = 0; i < numConnTypes; i++)
4780     {
4781         // If CA status is not initialized, CASelectNetwork() will not be called.
4782         if (caResult != CA_STATUS_NOT_INITIALIZED)
4783         {
4784            caResult = CASelectNetwork(connTypes[i]);
4785            if (caResult == CA_STATUS_OK)
4786            {
4787                retResult = CA_STATUS_OK;
4788            }
4789         }
4790     }
4791
4792     if (retResult != CA_STATUS_OK)
4793     {
4794         return caResult; // Returns error of appropriate transport that failed fatally.
4795     }
4796
4797     return retResult;
4798 }
4799
4800 OCStackResult CAResultToOCResult(CAResult_t caResult)
4801 {
4802     switch (caResult)
4803     {
4804         case CA_STATUS_OK:
4805             return OC_STACK_OK;
4806         case CA_STATUS_INVALID_PARAM:
4807             return OC_STACK_INVALID_PARAM;
4808         case CA_ADAPTER_NOT_ENABLED:
4809             return OC_STACK_ADAPTER_NOT_ENABLED;
4810         case CA_SERVER_STARTED_ALREADY:
4811             return OC_STACK_OK;
4812         case CA_SERVER_NOT_STARTED:
4813             return OC_STACK_ERROR;
4814         case CA_DESTINATION_NOT_REACHABLE:
4815             return OC_STACK_COMM_ERROR;
4816         case CA_SOCKET_OPERATION_FAILED:
4817             return OC_STACK_COMM_ERROR;
4818         case CA_SEND_FAILED:
4819             return OC_STACK_COMM_ERROR;
4820         case CA_RECEIVE_FAILED:
4821             return OC_STACK_COMM_ERROR;
4822         case CA_MEMORY_ALLOC_FAILED:
4823             return OC_STACK_NO_MEMORY;
4824         case CA_REQUEST_TIMEOUT:
4825             return OC_STACK_TIMEOUT;
4826         case CA_DESTINATION_DISCONNECTED:
4827             return OC_STACK_COMM_ERROR;
4828         case CA_STATUS_FAILED:
4829             return OC_STACK_ERROR;
4830         case CA_NOT_SUPPORTED:
4831             return OC_STACK_NOTIMPL;
4832         default:
4833             return OC_STACK_ERROR;
4834     }
4835 }
4836
4837 bool OCResultToSuccess(OCStackResult ocResult)
4838 {
4839     switch (ocResult)
4840     {
4841         case OC_STACK_OK:
4842         case OC_STACK_RESOURCE_CREATED:
4843         case OC_STACK_RESOURCE_DELETED:
4844         case OC_STACK_CONTINUE:
4845         case OC_STACK_RESOURCE_CHANGED:
4846         case OC_STACK_SLOW_RESOURCE:
4847             return true;
4848         default:
4849             return false;
4850     }
4851 }
4852
4853 #ifdef WITH_CHPROXY
4854 OCStackResult OCSetProxyURI(const char *uri)
4855 {
4856     return CAResultToOCResult(CASetProxyUri(uri));
4857 }
4858 #endif
4859
4860 #if defined(RD_CLIENT) || defined(RD_SERVER)
4861 OCStackResult OCBindResourceInsToResource(OCResourceHandle handle, uint8_t ins)
4862 {
4863     VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
4864
4865     OCResource *resource = NULL;
4866
4867     resource = findResource((OCResource *) handle);
4868     if (!resource)
4869     {
4870         OIC_LOG(ERROR, TAG, "Resource not found");
4871         return OC_STACK_ERROR;
4872     }
4873
4874     resource->ins = ins;
4875
4876     return OC_STACK_OK;
4877 }
4878
4879 OCResourceHandle OCGetResourceHandleAtUri(const char *uri)
4880 {
4881     if (!uri)
4882     {
4883         OIC_LOG(ERROR, TAG, "Resource uri is NULL");
4884         return NULL;
4885     }
4886
4887     OCResource *pointer = headResource;
4888
4889     while (pointer)
4890     {
4891         if (strncmp(uri, pointer->uri, MAX_URI_LENGTH) == 0)
4892         {
4893             OIC_LOG_V(DEBUG, TAG, "Found Resource %s", uri);
4894             return pointer;
4895         }
4896         pointer = pointer->next;
4897     }
4898     return NULL;
4899 }
4900
4901 OCStackResult OCGetResourceIns(OCResourceHandle handle, uint8_t *ins)
4902 {
4903     OCResource *resource = NULL;
4904
4905     VERIFY_NON_NULL(handle, ERROR, OC_STACK_INVALID_PARAM);
4906     VERIFY_NON_NULL(ins, ERROR, OC_STACK_INVALID_PARAM);
4907
4908     resource = findResource((OCResource *) handle);
4909     if (resource)
4910     {
4911         *ins = resource->ins;
4912         return OC_STACK_OK;
4913     }
4914     return OC_STACK_ERROR;
4915 }
4916
4917 OCStackResult OCSetHeaderOption(OCHeaderOption* ocHdrOpt, size_t* numOptions, uint16_t optionID,
4918         void* optionData, size_t optionDataLength)
4919 {
4920     if (!ocHdrOpt)
4921     {
4922         OIC_LOG (INFO, TAG, "Header options are NULL");
4923         return OC_STACK_INVALID_PARAM;
4924     }
4925
4926     if (!optionData)
4927     {
4928         OIC_LOG (INFO, TAG, "optionData are NULL");
4929         return OC_STACK_INVALID_PARAM;
4930     }
4931
4932     if (!numOptions)
4933     {
4934         OIC_LOG (INFO, TAG, "numOptions is NULL");
4935         return OC_STACK_INVALID_PARAM;
4936     }
4937
4938     if (*numOptions >= MAX_HEADER_OPTIONS)
4939     {
4940         OIC_LOG (INFO, TAG, "Exceeding MAX_HEADER_OPTIONS");
4941         return OC_STACK_NO_MEMORY;
4942     }
4943
4944     ocHdrOpt += *numOptions;
4945     ocHdrOpt->protocolID = OC_COAP_ID;
4946     ocHdrOpt->optionID = optionID;
4947     ocHdrOpt->optionLength =
4948             optionDataLength < MAX_HEADER_OPTION_DATA_LENGTH ?
4949                     optionDataLength : MAX_HEADER_OPTION_DATA_LENGTH;
4950     memcpy(ocHdrOpt->optionData, (const void*) optionData, ocHdrOpt->optionLength);
4951     *numOptions += 1;
4952
4953     return OC_STACK_OK;
4954 }
4955 OCStackResult OCGetHeaderOption(OCHeaderOption* ocHdrOpt, size_t numOptions, uint16_t optionID,
4956         void* optionData, size_t optionDataLength, uint16_t* receivedDataLength)
4957 {
4958     if (!ocHdrOpt || !numOptions)
4959     {
4960         OIC_LOG (INFO, TAG, "No options present");
4961         return OC_STACK_OK;
4962     }
4963
4964     if (!optionData)
4965     {
4966         OIC_LOG (INFO, TAG, "optionData are NULL");
4967         return OC_STACK_INVALID_PARAM;
4968     }
4969
4970     if (!receivedDataLength)
4971     {
4972         OIC_LOG (INFO, TAG, "receivedDataLength is NULL");
4973         return OC_STACK_INVALID_PARAM;
4974     }
4975
4976     for (uint8_t i = 0; i < numOptions; i++)
4977     {
4978         if (ocHdrOpt[i].optionID == optionID)
4979         {
4980             if (optionDataLength >= ocHdrOpt->optionLength)
4981             {
4982                 memcpy(optionData, ocHdrOpt->optionData, ocHdrOpt->optionLength);
4983                 *receivedDataLength = ocHdrOpt->optionLength;
4984                 return OC_STACK_OK;
4985             }
4986             else
4987             {
4988                 OIC_LOG (ERROR, TAG, "optionDataLength is less than the length of received data");
4989                 return OC_STACK_ERROR;
4990             }
4991         }
4992     }
4993     return OC_STACK_OK;
4994 }
4995 #endif
4996
4997 void OCDefaultAdapterStateChangedHandler(CATransportAdapter_t adapter, bool enabled)
4998 {
4999     OIC_LOG(DEBUG, TAG, "OCDefaultAdapterStateChangedHandler");
5000     if (g_adapterHandler)
5001     {
5002         g_adapterHandler(adapter, enabled);
5003     }
5004 }
5005
5006 void OCDefaultConnectionStateChangedHandler(const CAEndpoint_t *info, bool isConnected)
5007 {
5008     OIC_LOG(DEBUG, TAG, "OCDefaultConnectionStateChangedHandler");
5009     if (g_connectionHandler)
5010     {
5011        g_connectionHandler(info, isConnected);
5012     }
5013 }
5014
5015 void OCSetNetworkMonitorHandler(CAAdapterStateChangedCB adapterHandler,
5016                                 CAConnectionStateChangedCB connectionHandler)
5017 {
5018     OIC_LOG(DEBUG, TAG, "OCSetNetworkMonitorHandler");
5019     g_adapterHandler = adapterHandler;
5020     g_connectionHandler = connectionHandler;
5021 }
5022