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