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