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