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