Integrated WIFI/ETHERNET adapters to single IPAdapter.
[platform/upstream/iotivity.git] / 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