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