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