resource/csdk/stack/src/ocserverrequest.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 #include <string.h>
  21
  22 #include "ocstack.h"
  23 #include "ocserverrequest.h"
  24 #include "ocresourcehandler.h"
  25 #include "ocobserve.h"
  26 #include "oic_malloc.h"
  27 #include "oic_string.h"
  28 #include "ocpayload.h"
  29 #include "ocpayloadcbor.h"
  30 #include "logger.h"
  31
  32 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
  33 #include "routingutility.h"
  34 #endif
  35
  36 #include "cacommon.h"
  37 #include "cainterface.h"
  38
  39 #include <coap/utlist.h>
  40 #include <coap/pdu.h>
  41
  42 // Module Name
  43 #define VERIFY_NON_NULL(arg) { if (!arg) {OIC_LOG(FATAL, TAG, #arg " is NULL"); goto exit;} }
  44
  45 #define TAG  "OIC_RI_SERVERREQUEST"
  46
  47 static struct OCServerRequest * serverRequestList = NULL;
  48 static struct OCServerResponse * serverResponseList = NULL;
  49
  50 //-------------------------------------------------------------------------------------------------
  51 // Local functions
  52 //-------------------------------------------------------------------------------------------------
  53
  54 /**
  55  * Add a server response to the server response list
  56  *
  57  * @param response initialized server response that is created by this function
  58  * @param requestHandle - handle of the response
  59  *
  60  * @return
  61  *     OCStackResult
  62  */
  63 static OCStackResult AddServerResponse (OCServerResponse ** response, OCRequestHandle requestHandle)
  64 {
  65     if (!response)
  66     {
  67         return OC_STACK_INVALID_PARAM;
  68     }
  69
  70     OCServerResponse * serverResponse = NULL;
  71
  72     serverResponse = (OCServerResponse *) OICCalloc(1, sizeof(OCServerResponse));
  73     VERIFY_NON_NULL(serverResponse);
  74
  75     serverResponse->payload = NULL;
  76
  77     serverResponse->requestHandle = requestHandle;
  78
  79     *response = serverResponse;
  80     OIC_LOG(INFO, TAG, "Server Response Added!!");
  81     LL_APPEND (serverResponseList, serverResponse);
  82     return OC_STACK_OK;
  83
  84 exit:
  85     if (serverResponse)
  86     {
  87         OICFree(serverResponse);
  88         serverResponse = NULL;
  89     }
  90     *response = NULL;
  91     return OC_STACK_NO_MEMORY;
  92 }
  93
  94 /**
  95  * Delete a server request from the server request list
  96  *
  97  * @param serverRequest - server request to delete
  98  */
  99 static void DeleteServerRequest(OCServerRequest * serverRequest)
 100 {
 101     if(serverRequest)
 102     {
 103         LL_DELETE(serverRequestList, serverRequest);
 104         OICFree(serverRequest->requestToken);
 105         OICFree(serverRequest->rcvdVendorSpecificHeaderOptions);
 106         OICFree(serverRequest);
 107         serverRequest = NULL;
 108         OIC_LOG(INFO, TAG, "Server Request Removed!!");
 109     }
 110 }
 111
 112 /**
 113  * Delete a server response from the server response list
 114  *
 115  * @param serverResponse - server response to delete
 116  */
 117 static void DeleteServerResponse(OCServerResponse * serverResponse)
 118 {
 119     if(serverResponse)
 120     {
 121         LL_DELETE(serverResponseList, serverResponse);
 122         OCPayloadDestroy(serverResponse->payload);
 123         OICFree(serverResponse);
 124         OIC_LOG(INFO, TAG, "Server Response Removed!!");
 125     }
 126 }
 127
 128 /**
 129  * Find a server response and delete it from the server response list
 130  *
 131  * @param serverResponse - server response to find and delete
 132  */
 133 static void FindAndDeleteServerResponse(OCServerResponse * serverResponse)
 134 {
 135     OCServerResponse* tmp;
 136     if(serverResponse)
 137     {
 138         LL_FOREACH(serverResponseList, tmp)
 139         {
 140             if (serverResponse == tmp)
 141             {
 142                 DeleteServerResponse(tmp);
 143                 return;
 144             }
 145         }
 146     }
 147 }
 148
 149 /**
 150  * Ensure no accept header option is included when sending responses and add routing info to
 151  * outgoing response.
 152  *
 153  * @param object CA remote endpoint.
 154  * @param requestInfo CA request info.
 155  *
 156  * @return ::OC_STACK_OK on success, some other value upon failure.
 157  */
 158 static OCStackResult OCSendResponse(const CAEndpoint_t *object, CAResponseInfo_t *responseInfo)
 159 {
 160 #if defined (ROUTING_GATEWAY) || defined (ROUTING_EP)
 161     // Add route info in RM option.
 162     OCStackResult rmResult = RMAddInfo(object->routeData, responseInfo, false, NULL);
 163     if(OC_STACK_OK != rmResult)
 164     {
 165         OIC_LOG(ERROR, TAG, "Add option failed");
 166         return rmResult;
 167     }
 168 #endif
 169
 170     // Do not include the accept header option
 171     responseInfo->info.acceptFormat = CA_FORMAT_UNDEFINED;
 172     CAResult_t result = CASendResponse(object, responseInfo);
 173     if(CA_STATUS_OK != result)
 174     {
 175         OIC_LOG_V(ERROR, TAG, "CASendResponse failed with CA error %u", result);
 176         return CAResultToOCResult(result);
 177     }
 178     return OC_STACK_OK;
 179 }
 180
 181 //-------------------------------------------------------------------------------------------------
 182 // Internal APIs
 183 //-------------------------------------------------------------------------------------------------
 184
 185 /**
 186  * Get a server request from the server request list using the specified token.
 187  *
 188  * @param token - token of server request
 189  * @param tokenLength - length of token
 190  *
 191  * @return
 192  *     OCServerRequest*
 193  */
 194 OCServerRequest * GetServerRequestUsingToken (const CAToken_t token, uint8_t tokenLength)
 195 {
 196     if(!token)
 197     {
 198         OIC_LOG(ERROR, TAG, "Invalid Parameter Token");
 199         return NULL;
 200     }
 201
 202     OCServerRequest * out = NULL;
 203     OIC_LOG(INFO, TAG,"Get server request with token");
 204     OIC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, tokenLength);
 205
 206     OIC_LOG(INFO, TAG, "Found token");
 207     LL_FOREACH (serverRequestList, out)
 208     {
 209         if(out)
 210         {
 211             OIC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->requestToken, out->tokenLength);
 212             if((tokenLength == out->tokenLength) &&
 213                 memcmp(out->requestToken, token, tokenLength) == 0)
 214             {
 215                 return out;
 216             }
 217         }
 218     }
 219     OIC_LOG(INFO, TAG, "Server Request not found!!");
 220     return NULL;
 221 }
 222
 223 /**
 224  * Get a server request from the server request list using the specified handle
 225  *
 226  * @param handle - handle of server request
 227  * @return
 228  *     OCServerRequest*
 229  */
 230 OCServerRequest * GetServerRequestUsingHandle (const OCRequestHandle handle)
 231 {
 232     OCServerRequest * out = NULL;
 233     LL_FOREACH (serverRequestList, out)
 234     {
 235         if(out->requestId == handle)
 236         {
 237             return out;
 238         }
 239     }
 240     OIC_LOG(ERROR, TAG, "Server Request not found!!");
 241     return NULL;
 242 }
 243
 244 /**
 245  * Get a server response from the server response list using the specified handle
 246  *
 247  * @param handle - handle of server response
 248  *
 249  * @return
 250  *     OCServerResponse*
 251  */
 252 OCServerResponse * GetServerResponseUsingHandle (const OCRequestHandle handle)
 253 {
 254     OCServerResponse * out = NULL;
 255     LL_FOREACH (serverResponseList, out)
 256     {
 257         if(out->requestHandle == handle)
 258         {
 259             return out;
 260         }
 261     }
 262     OIC_LOG(INFO, TAG, "Server Response not found!!");
 263     return NULL;
 264 }
 265
 266 OCStackResult AddServerRequest (OCServerRequest ** request, uint16_t coapID,
 267         uint8_t delayedResNeeded, uint8_t notificationFlag, OCMethod method,
 268         uint8_t numRcvdVendorSpecificHeaderOptions, uint32_t observationOption,
 269         OCQualityOfService qos, char * query,
 270         OCHeaderOption * rcvdVendorSpecificHeaderOptions,
 271         uint8_t * payload, CAToken_t requestToken, uint8_t tokenLength,
 272         char * resourceUrl, size_t reqTotalSize, OCPayloadFormat acceptFormat,
 273         const OCDevAddr *devAddr)
 274 {
 275     if (!request)
 276     {
 277         return OC_STACK_INVALID_PARAM;
 278     }
 279
 280     OCServerRequest * serverRequest = NULL;
 281
 282     OIC_LOG_V(INFO, TAG, "addserverrequest entry!! [%s:%u]", devAddr->addr, devAddr->port);
 283
 284     serverRequest = (OCServerRequest *) OICCalloc(1, sizeof(OCServerRequest) +
 285         (reqTotalSize ? reqTotalSize : 1) - 1);
 286     VERIFY_NON_NULL(devAddr);
 287     VERIFY_NON_NULL(serverRequest);
 288
 289     serverRequest->coapID = coapID;
 290     serverRequest->delayedResNeeded = delayedResNeeded;
 291     serverRequest->notificationFlag = notificationFlag;
 292
 293     serverRequest->method = method;
 294     serverRequest->numRcvdVendorSpecificHeaderOptions = numRcvdVendorSpecificHeaderOptions;
 295     serverRequest->observationOption = observationOption;
 296     serverRequest->observeResult = OC_STACK_ERROR;
 297     serverRequest->qos = qos;
 298     serverRequest->acceptFormat = acceptFormat;
 299     serverRequest->ehResponseHandler = HandleSingleResponse;
 300     serverRequest->numResponses = 1;
 301     serverRequest->requestId = OCGetRandom();
 302
 303     if(query)
 304     {
 305         OICStrcpy(serverRequest->query, sizeof(serverRequest->query), query);
 306     }
 307
 308     if(rcvdVendorSpecificHeaderOptions)
 309     {
 310         serverRequest->rcvdVendorSpecificHeaderOptions =
 311                     (OCHeaderOption *) OICCalloc(numRcvdVendorSpecificHeaderOptions, sizeof(OCHeaderOption));
 312         VERIFY_NON_NULL(serverRequest->rcvdVendorSpecificHeaderOptions);
 313
 314         memcpy(serverRequest->rcvdVendorSpecificHeaderOptions, rcvdVendorSpecificHeaderOptions,
 315             numRcvdVendorSpecificHeaderOptions * sizeof(OCHeaderOption));
 316     }
 317     if(payload && reqTotalSize)
 318     {
 319         // destination is at least 1 greater than the source, so a NULL always exists in the
 320         // last character
 321         memcpy(serverRequest->payload, payload, reqTotalSize);
 322         serverRequest->payloadSize = reqTotalSize;
 323     }
 324
 325     serverRequest->requestComplete = 0;
 326     if(requestToken)
 327     {
 328          // If tokenLength is zero, the return value depends on the
 329          // particular library implementation (it may or may not be a null pointer).
 330         if (tokenLength)
 331         {
 332             serverRequest->requestToken = (CAToken_t) OICMalloc(tokenLength);
 333             VERIFY_NON_NULL(serverRequest->requestToken);
 334             memcpy(serverRequest->requestToken, requestToken, tokenLength);
 335         }
 336     }
 337     serverRequest->tokenLength = tokenLength;
 338
 339     if(resourceUrl)
 340     {
 341         OICStrcpy(serverRequest->resourceUrl, sizeof(serverRequest->resourceUrl),
 342             resourceUrl);
 343     }
 344
 345     serverRequest->devAddr = *devAddr;
 346
 347     *request = serverRequest;
 348     OIC_LOG(INFO, TAG, "Server Request Added!!");
 349     LL_APPEND (serverRequestList, serverRequest);
 350     return OC_STACK_OK;
 351
 352 exit:
 353     if (serverRequest)
 354     {
 355         OICFree(serverRequest->requestToken);
 356         OICFree(serverRequest->rcvdVendorSpecificHeaderOptions);
 357         OICFree(serverRequest);
 358         serverRequest = NULL;
 359     }
 360     *request = NULL;
 361     return OC_STACK_NO_MEMORY;
 362 }
 363
 364 OCStackResult FormOCEntityHandlerRequest(
 365         OCEntityHandlerRequest * entityHandlerRequest,
 366         OCRequestHandle request,
 367         OCMethod method,
 368         OCDevAddr *endpoint,
 369         OCResourceHandle resource,
 370         char * queryBuf,
 371         OCPayloadType payloadType,
 372         uint8_t * payload,
 373         size_t payloadSize,
 374         uint8_t numVendorOptions,
 375         OCHeaderOption * vendorOptions,
 376         OCObserveAction observeAction,
 377         OCObservationId observeID,
 378         uint16_t messageID)
 379 {
 380     if (entityHandlerRequest)
 381     {
 382         entityHandlerRequest->resource = (OCResourceHandle) resource;
 383         entityHandlerRequest->requestHandle = request;
 384         entityHandlerRequest->method = method;
 385         entityHandlerRequest->devAddr = *endpoint;
 386         entityHandlerRequest->query = queryBuf;
 387         entityHandlerRequest->obsInfo.action = observeAction;
 388         entityHandlerRequest->obsInfo.obsId = observeID;
 389         entityHandlerRequest->messageID = messageID;
 390
 391         if(payload && payloadSize)
 392         {
 393             if(OCParsePayload(&entityHandlerRequest->payload, payloadType,
 394                         payload, payloadSize) != OC_STACK_OK)
 395             {
 396                 return OC_STACK_ERROR;
 397             }
 398         }
 399         else
 400         {
 401             entityHandlerRequest->payload = NULL;
 402         }
 403
 404         entityHandlerRequest->numRcvdVendorSpecificHeaderOptions = numVendorOptions;
 405         entityHandlerRequest->rcvdVendorSpecificHeaderOptions = vendorOptions;
 406
 407         return OC_STACK_OK;
 408     }
 409
 410     return OC_STACK_INVALID_PARAM;
 411 }
 412
 413 /**
 414  * Find a server request in the server request list and delete
 415  *
 416  * @param serverRequest - server request to find and delete
 417  */
 418 void FindAndDeleteServerRequest(OCServerRequest * serverRequest)
 419 {
 420     OCServerRequest* tmp;
 421     if(serverRequest)
 422     {
 423         LL_FOREACH(serverRequestList, tmp)
 424         {
 425             if (serverRequest == tmp)
 426             {
 427                 DeleteServerRequest(tmp);
 428                 return;
 429             }
 430         }
 431     }
 432 }
 433
 434 CAResponseResult_t ConvertEHResultToCAResult (OCEntityHandlerResult result, OCMethod method)
 435 {
 436     CAResponseResult_t caResult = CA_BAD_REQ;
 437
 438     switch (result)
 439     {
 440         // Successful Client Request
 441         case OC_EH_RESOURCE_CREATED: // 2.01
 442             if (method == OC_REST_POST || method == OC_REST_PUT)
 443             {
 444                 caResult = CA_CREATED;
 445             }
 446             break;
 447         case OC_EH_RESOURCE_DELETED: // 2.02
 448             if (method == OC_REST_POST || method == OC_REST_DELETE)
 449             {
 450                 caResult = CA_DELETED;
 451             }
 452             break;
 453         case OC_EH_SLOW: // 2.05
 454             caResult = CA_CONTENT;
 455             break;
 456         case OC_EH_OK:
 457         case OC_EH_CHANGED: // 2.04
 458         case OC_EH_CONTENT: // 2.05
 459             if (method == OC_REST_POST || method == OC_REST_PUT)
 460             {
 461                 caResult = CA_CHANGED;
 462             }
 463             else if (method == OC_REST_GET)
 464             {
 465                 caResult = CA_CONTENT;
 466             }
 467             break;
 468         case OC_EH_VALID: // 2.03
 469             caResult = CA_VALID;
 470             break;
 471         // Unsuccessful Client Request
 472         case OC_EH_UNAUTHORIZED_REQ: // 4.01
 473             caResult = CA_UNAUTHORIZED_REQ;
 474             break;
 475         case OC_EH_BAD_OPT: // 4.02
 476             caResult = CA_BAD_OPT;
 477             break;
 478         case OC_EH_FORBIDDEN: // 4.03
 479             caResult = CA_FORBIDDEN_REQ;
 480             break;
 481         case OC_EH_RESOURCE_NOT_FOUND: // 4.04
 482             caResult = CA_NOT_FOUND;
 483             break;
 484         case OC_EH_METHOD_NOT_ALLOWED: // 4.05
 485             caResult = CA_METHOD_NOT_ALLOWED;
 486             break;
 487         case OC_EH_NOT_ACCEPTABLE: // 4.06
 488             caResult = CA_NOT_ACCEPTABLE;
 489             break;
 490         case OC_EH_TOO_MANY_REQUESTS: // 4.29
 491             caResult = CA_TOO_MANY_REQUESTS;
 492             break;
 493         case OC_EH_INTERNAL_SERVER_ERROR: // 5.00
 494             caResult = CA_INTERNAL_SERVER_ERROR;
 495             break;
 496         case OC_EH_NOT_IMPLEMENTED: // 5.01
 497             caResult = CA_NOT_IMPLEMENTED;
 498             break;
 499         case OC_EH_BAD_GATEWAY: // 5.02
 500             caResult = CA_BAD_GATEWAY;
 501             break;
 502         case OC_EH_SERVICE_UNAVAILABLE: // 5.03
 503             caResult = CA_SERVICE_UNAVAILABLE;
 504             break;
 505         case OC_EH_RETRANSMIT_TIMEOUT: // 5.04
 506             caResult = CA_RETRANSMIT_TIMEOUT;
 507             break;
 508         case OC_EH_PROXY_NOT_SUPPORTED: // 5.05
 509             caResult = CA_PROXY_NOT_SUPPORTED;
 510             break;
 511         default:
 512             caResult = CA_BAD_REQ;
 513             break;
 514     }
 515     return caResult;
 516 }
 517
 518
 519 /**
 520  * Handler function for sending a response from a single resource
 521  *
 522  * @param ehResponse - pointer to the response from the resource
 523  *
 524  * @return
 525  *     OCStackResult
 526  */
 527 OCStackResult HandleSingleResponse(OCEntityHandlerResponse * ehResponse)
 528 {
 529     OCStackResult result = OC_STACK_ERROR;
 530     CAEndpoint_t responseEndpoint = {.adapter = CA_DEFAULT_ADAPTER};
 531     CAResponseInfo_t responseInfo = {.result = CA_EMPTY};
 532     CAHeaderOption_t* optionsPointer = NULL;
 533
 534     if(!ehResponse || !ehResponse->requestHandle)
 535     {
 536         OIC_LOG(ERROR, TAG, "ehResponse/requestHandle is NULL");
 537         return OC_STACK_ERROR;
 538     }
 539
 540     OCServerRequest *serverRequest = GetServerRequestUsingHandle(ehResponse->requestHandle);
 541     if (NULL == serverRequest)
 542     {
 543         OIC_LOG(ERROR, TAG, "No serverRequest matching with ehResponse");
 544         return OC_STACK_ERROR;
 545     }
 546
 547     CopyDevAddrToEndpoint(&serverRequest->devAddr, &responseEndpoint);
 548
 549     responseInfo.info.messageId = serverRequest->coapID;
 550     responseInfo.info.resourceUri = serverRequest->resourceUrl;
 551     responseInfo.result = ConvertEHResultToCAResult(ehResponse->ehResult, serverRequest->method);
 552     responseInfo.info.dataType = CA_RESPONSE_DATA;
 553
 554     if(serverRequest->notificationFlag && serverRequest->qos == OC_HIGH_QOS)
 555     {
 556         responseInfo.info.type = CA_MSG_CONFIRM;
 557     }
 558     else if(serverRequest->notificationFlag && serverRequest->qos != OC_HIGH_QOS)
 559     {
 560         responseInfo.info.type = CA_MSG_NONCONFIRM;
 561     }
 562     else if(!serverRequest->notificationFlag && !serverRequest->slowFlag &&
 563             serverRequest->qos == OC_HIGH_QOS)
 564     {
 565         responseInfo.info.type = CA_MSG_ACKNOWLEDGE;
 566     }
 567     else if(!serverRequest->notificationFlag && serverRequest->slowFlag &&
 568             serverRequest->qos == OC_HIGH_QOS)
 569     {
 570         // To assign new messageId in CA.
 571         responseInfo.info.messageId = 0;
 572         responseInfo.info.type = CA_MSG_CONFIRM;
 573     }
 574     else if(!serverRequest->notificationFlag)
 575     {
 576         responseInfo.info.type = CA_MSG_NONCONFIRM;
 577     }
 578     else
 579     {
 580         OIC_LOG(ERROR, TAG, "default responseInfo type is NON");
 581         responseInfo.info.type = CA_MSG_NONCONFIRM;
 582     }
 583
 584     char rspToken[CA_MAX_TOKEN_LEN + 1] = {0};
 585     responseInfo.info.messageId = serverRequest->coapID;
 586     responseInfo.info.token = (CAToken_t)rspToken;
 587
 588     memcpy(responseInfo.info.token, serverRequest->requestToken, serverRequest->tokenLength);
 589     responseInfo.info.tokenLength = serverRequest->tokenLength;
 590
 591     if((serverRequest->observeResult == OC_STACK_OK)&&
 592        (serverRequest->observationOption != MAX_SEQUENCE_NUMBER + 1))
 593     {
 594         responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions + 1;
 595     }
 596     else
 597     {
 598         responseInfo.info.numOptions = ehResponse->numSendVendorSpecificHeaderOptions;
 599     }
 600
 601     if(responseInfo.info.numOptions > 0)
 602     {
 603         responseInfo.info.options = (CAHeaderOption_t *)
 604                                       OICCalloc(responseInfo.info.numOptions,
 605                                               sizeof(CAHeaderOption_t));
 606
 607         if(!responseInfo.info.options)
 608         {
 609             OIC_LOG(FATAL, TAG, "Memory alloc for options failed");
 610             return OC_STACK_NO_MEMORY;
 611         }
 612
 613         optionsPointer = responseInfo.info.options;
 614
 615         // TODO: This exposes CoAP specific details.  At some point, this should be
 616         // re-factored and handled in the CA layer.
 617         if(serverRequest->observeResult == OC_STACK_OK)
 618         {
 619             responseInfo.info.options[0].protocolID = CA_COAP_ID;
 620             responseInfo.info.options[0].optionID = COAP_OPTION_OBSERVE;
 621             responseInfo.info.options[0].optionLength = sizeof(uint32_t);
 622             uint8_t* observationData = (uint8_t*)responseInfo.info.options[0].optionData;
 623             uint32_t observationOption= serverRequest->observationOption;
 624
 625             for (size_t i=sizeof(uint32_t); i; --i)
 626             {
 627                 observationData[i-1] = observationOption & 0xFF;
 628                 observationOption >>=8;
 629             }
 630
 631             // Point to the next header option before copying vender specific header options
 632             optionsPointer += 1;
 633         }
 634
 635         if (ehResponse->numSendVendorSpecificHeaderOptions)
 636         {
 637             memcpy(optionsPointer, ehResponse->sendVendorSpecificHeaderOptions,
 638                             sizeof(OCHeaderOption) *
 639                             ehResponse->numSendVendorSpecificHeaderOptions);
 640         }
 641     }
 642     else
 643     {
 644         responseInfo.info.options = NULL;
 645     }
 646
 647     responseInfo.isMulticast = false;
 648     responseInfo.info.payload = NULL;
 649     responseInfo.info.payloadSize = 0;
 650     responseInfo.info.payloadFormat = CA_FORMAT_UNDEFINED;
 651
 652     // Put the JSON prefix and suffix around the payload
 653     if(ehResponse->payload)
 654     {
 655 #ifdef WITH_PRESENCE
 656         if (ehResponse->payload->type == PAYLOAD_TYPE_PRESENCE)
 657         {
 658             responseInfo.isMulticast = true;
 659         }
 660         else
 661 #endif
 662         {
 663             responseInfo.isMulticast = false;
 664         }
 665
 666         switch(serverRequest->acceptFormat)
 667         {
 668             case OC_FORMAT_UNDEFINED:
 669                 // No preference set by the client, so default to CBOR then
 670             case OC_FORMAT_CBOR:
 671                 if((result = OCConvertPayload(ehResponse->payload, &responseInfo.info.payload,
 672                                 &responseInfo.info.payloadSize))
 673                         != OC_STACK_OK)
 674                 {
 675                     OIC_LOG(ERROR, TAG, "Error converting payload");
 676                     OICFree(responseInfo.info.options);
 677                     return result;
 678                 }
 679                 // Add CONTENT_FORMAT OPT if payload exist
 680                 if (responseInfo.info.payloadSize > 0)
 681                 {
 682                     responseInfo.info.payloadFormat = CA_FORMAT_APPLICATION_CBOR;
 683                 }
 684                 break;
 685             default:
 686                 responseInfo.result = CA_NOT_ACCEPTABLE;
 687         }
 688     }
 689
 690 #ifdef WITH_PRESENCE
 691     CATransportAdapter_t CAConnTypes[] = {
 692                             CA_ADAPTER_IP,
 693                             CA_ADAPTER_GATT_BTLE,
 694                             CA_ADAPTER_RFCOMM_BTEDR,
 695                             CA_ADAPTER_NFC
 696 #ifdef RA_ADAPTER
 697                             , CA_ADAPTER_REMOTE_ACCESS
 698 #endif
 699                             , CA_ADAPTER_TCP
 700                         };
 701
 702     size_t size = sizeof(CAConnTypes)/ sizeof(CATransportAdapter_t);
 703
 704     CATransportAdapter_t adapter = responseEndpoint.adapter;
 705     // Default adapter, try to send response out on all adapters.
 706     if (adapter == CA_DEFAULT_ADAPTER)
 707     {
 708         adapter =
 709             (CATransportAdapter_t)(
 710                 CA_ADAPTER_IP           |
 711                 CA_ADAPTER_GATT_BTLE    |
 712                 CA_ADAPTER_RFCOMM_BTEDR |
 713                 CA_ADAPTER_NFC
 714 #ifdef RA_ADAP
 715                 | CA_ADAPTER_REMOTE_ACCESS
 716 #endif
 717                 | CA_ADAPTER_TCP
 718             );
 719     }
 720
 721     result = OC_STACK_OK;
 722     OCStackResult tempResult = OC_STACK_OK;
 723
 724     for(size_t i = 0; i < size; i++ )
 725     {
 726         responseEndpoint.adapter = (CATransportAdapter_t)(adapter & CAConnTypes[i]);
 727         if(responseEndpoint.adapter)
 728         {
 729             //The result is set to OC_STACK_OK only if OCSendResponse succeeds in sending the
 730             //response on all the n/w interfaces else it is set to OC_STACK_ERROR
 731             tempResult = OCSendResponse(&responseEndpoint, &responseInfo);
 732         }
 733         if(OC_STACK_OK != tempResult)
 734         {
 735             result = tempResult;
 736         }
 737     }
 738 #else
 739
 740     OIC_LOG(INFO, TAG, "Calling OCSendResponse with:");
 741     OIC_LOG_V(INFO, TAG, "\tEndpoint address: %s", responseEndpoint.addr);
 742     OIC_LOG_V(INFO, TAG, "\tEndpoint adapter: %s", responseEndpoint.adapter);
 743     OIC_LOG_V(INFO, TAG, "\tResponse result : %s", responseInfo.result);
 744     OIC_LOG_V(INFO, TAG, "\tResponse for uri: %s", responseInfo.info.resourceUri);
 745
 746     result = OCSendResponse(&responseEndpoint, &responseInfo);
 747 #endif
 748
 749     OICFree(responseInfo.info.payload);
 750     OICFree(responseInfo.info.options);
 751     //Delete the request
 752     FindAndDeleteServerRequest(serverRequest);
 753     return result;
 754 }
 755
 756 /**
 757  * Handler function for sending a response from multiple resources, such as a collection.
 758  * Aggregates responses from multiple resource until all responses are received then sends the
 759  * concatenated response
 760  *
 761  * TODO: Need to add a timeout in case a (remote?) resource does not respond
 762  *
 763  * @param ehResponse - pointer to the response from the resource
 764  *
 765  * @return
 766  *     OCStackResult
 767  */
 768 OCStackResult HandleAggregateResponse(OCEntityHandlerResponse * ehResponse)
 769 {
 770     if(!ehResponse || !ehResponse->payload)
 771     {
 772         OIC_LOG(ERROR, TAG, "HandleAggregateResponse invalid parameters");
 773         return OC_STACK_INVALID_PARAM;
 774     }
 775
 776     OIC_LOG(INFO, TAG, "Inside HandleAggregateResponse");
 777
 778     OCServerRequest *serverRequest = GetServerRequestUsingHandle(ehResponse->requestHandle);
 779     OCServerResponse *serverResponse = GetServerResponseUsingHandle(ehResponse->requestHandle);
 780
 781     OCStackResult stackRet = OC_STACK_ERROR;
 782     if(serverRequest)
 783     {
 784         if(!serverResponse)
 785         {
 786             OIC_LOG(INFO, TAG, "This is the first response fragment");
 787             stackRet = AddServerResponse(&serverResponse, ehResponse->requestHandle);
 788             if (OC_STACK_OK != stackRet)
 789             {
 790                 OIC_LOG(ERROR, TAG, "Error adding server response");
 791                 return stackRet;
 792             }
 793             VERIFY_NON_NULL(serverResponse);
 794         }
 795
 796         if(ehResponse->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 797         {
 798             stackRet = OC_STACK_ERROR;
 799             OIC_LOG(ERROR, TAG, "Error adding payload, as it was the incorrect type");
 800             goto exit;
 801         }
 802
 803         OCRepPayload *newPayload = OCRepPayloadBatchClone((OCRepPayload *)ehResponse->payload);
 804
 805         if(!serverResponse->payload)
 806         {
 807             serverResponse->payload = (OCPayload *)newPayload;
 808         }
 809         else
 810         {
 811             OCRepPayloadAppend((OCRepPayload*)serverResponse->payload,
 812                     (OCRepPayload*)newPayload);
 813         }
 814
 815         (serverRequest->numResponses)--;
 816
 817         if(serverRequest->numResponses == 0)
 818         {
 819             OIC_LOG(INFO, TAG, "This is the last response fragment");
 820             ehResponse->payload = serverResponse->payload;
 821             ehResponse->ehResult = OC_EH_OK;
 822             stackRet = HandleSingleResponse(ehResponse);
 823             //Delete the request and response
 824             FindAndDeleteServerRequest(serverRequest);
 825             FindAndDeleteServerResponse(serverResponse);
 826         }
 827         else
 828         {
 829             OIC_LOG(INFO, TAG, "More response fragments to come");
 830             stackRet = OC_STACK_OK;
 831         }
 832     }
 833 exit:
 834
 835     return stackRet;
 836 }