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