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