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