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