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