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     LL_FOREACH (serverRequestList, out)
 160     {
 161         OC_LOG(INFO, TAG,PCF("comparing tokens"));
 162         OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)token, tokenLength);
 163         OC_LOG_BUFFER(INFO, TAG, (const uint8_t *)out->requestToken, tokenLength);
 164         if(memcmp(out->requestToken, token, tokenLength) == 0)
 165         {
 166             return out;
 167         }
 168     }
 169     OC_LOG(ERROR, TAG, PCF("Server Request not found!!"));
 170     return NULL;
 171 }
 172
 173 /**
 174  * Get a server request from the server request list using the specified handle
 175  *
 176  * @param handle - handle of server request
 177  * @return
 178  *     OCServerRequest*
 179  */
 180 OCServerRequest * GetServerRequestUsingHandle (const OCServerRequest * handle)
 181 {
 182     OCServerRequest * out = NULL;
 183     LL_FOREACH (serverRequestList, out)
 184     {
 185         if(out == handle)
 186         {
 187             return out;
 188         }
 189     }
 190     OC_LOG(ERROR, TAG, PCF("Server Request not found!!"));
 191     return NULL;
 192 }
 193
 194 /**
 195  * Get a server response from the server response list using the specified handle
 196  *
 197  * @param handle - handle of server response
 198  *
 199  * @return
 200  *     OCServerResponse*
 201  */
 202 OCServerResponse * GetServerResponseUsingHandle (const OCServerRequest * handle)
 203 {
 204     OCServerResponse * out = NULL;
 205     LL_FOREACH (serverResponseList, out)
 206     {
 207         if(out->requestHandle == handle)
 208         {
 209             return out;
 210         }
 211     }
 212     OC_LOG(ERROR, TAG, PCF("Server Response not found!!"));
 213     return NULL;
 214 }
 215
 216 OCStackResult AddServerRequest (OCServerRequest ** request, uint16_t coapID,
 217         uint8_t delayedResNeeded, uint8_t notificationFlag, OCMethod method,
 218         uint8_t numRcvdVendorSpecificHeaderOptions, uint32_t observationOption,
 219         OCQualityOfService qos, char * query,
 220         OCHeaderOption * rcvdVendorSpecificHeaderOptions,
 221         uint8_t * payload, CAToken_t requestToken, uint8_t tokenLength,
 222         char * resourceUrl, size_t reqTotalSize, const OCDevAddr *devAddr)
 223 {
 224     OCServerRequest * serverRequest = NULL;
 225
 226     serverRequest = (OCServerRequest *) OICCalloc(1, sizeof(OCServerRequest) +
 227         (reqTotalSize ? reqTotalSize : 1) - 1);
 228     VERIFY_NON_NULL(devAddr);
 229     VERIFY_NON_NULL(serverRequest);
 230
 231     serverRequest->coapID = coapID;
 232     serverRequest->delayedResNeeded = delayedResNeeded;
 233     serverRequest->notificationFlag = notificationFlag;
 234
 235     serverRequest->method = method;
 236     serverRequest->numRcvdVendorSpecificHeaderOptions = numRcvdVendorSpecificHeaderOptions;
 237     serverRequest->observationOption = observationOption;
 238     serverRequest->observeResult = OC_STACK_ERROR;
 239     serverRequest->qos = qos;
 240     serverRequest->ehResponseHandler = HandleSingleResponse;
 241     serverRequest->numResponses = 1;
 242
 243     if(query)
 244     {
 245         OICStrcpy(serverRequest->query, sizeof(serverRequest->query), query);
 246     }
 247
 248     if(rcvdVendorSpecificHeaderOptions)
 249     {
 250         memcpy(serverRequest->rcvdVendorSpecificHeaderOptions, rcvdVendorSpecificHeaderOptions,
 251             MAX_HEADER_OPTIONS * sizeof(OCHeaderOption));
 252     }
 253     if(payload && reqTotalSize)
 254     {
 255        // destination is at least 1 greater than the source, so a NULL always exists in the
 256         // last character
 257         memcpy(serverRequest->payload, payload, reqTotalSize);
 258         serverRequest->payloadSize = reqTotalSize;
 259     }
 260
 261     serverRequest->requestComplete = 0;
 262     if(requestToken)
 263     {
 264         // If tokenLength is zero, the return value depends on the
 265         // particular library implementation (it may or may not be a null pointer).
 266         if (tokenLength)
 267         {
 268             serverRequest->requestToken = (CAToken_t) OICMalloc(tokenLength);
 269             VERIFY_NON_NULL(serverRequest->requestToken);
 270             memcpy(serverRequest->requestToken, requestToken, tokenLength);
 271         }
 272
 273     }
 274     serverRequest->tokenLength = tokenLength;
 275
 276     if(resourceUrl)
 277     {
 278         OICStrcpy(serverRequest->resourceUrl, sizeof(serverRequest->resourceUrl),
 279             resourceUrl);
 280     }
 281
 282     serverRequest->devAddr = *devAddr;
 283
 284     *request = serverRequest;
 285     OC_LOG(INFO, TAG, PCF("Server Request Added!!"));
 286     LL_APPEND (serverRequestList, serverRequest);
 287     return OC_STACK_OK;
 288
 289 exit:
 290     if (serverRequest)
 291     {
 292         OICFree(serverRequest);
 293         serverRequest = NULL;
 294     }
 295     *request = NULL;
 296     return OC_STACK_NO_MEMORY;
 297 }
 298
 299 OCStackResult FormOCEntityHandlerRequest(
 300         OCEntityHandlerRequest * entityHandlerRequest,
 301         OCRequestHandle request,
 302         OCMethod method,
 303         OCResourceHandle resource,
 304         char * queryBuf,
 305         uint8_t * payload,
 306         size_t payloadSize,
 307         uint8_t numVendorOptions,
 308         OCHeaderOption * vendorOptions,
 309         OCObserveAction observeAction,
 310         OCObservationId observeID)
 311 {
 312     if (entityHandlerRequest)
 313     {
 314         entityHandlerRequest->resource = (OCResourceHandle) resource;
 315         entityHandlerRequest->requestHandle = request;
 316         entityHandlerRequest->method = method;
 317         entityHandlerRequest->query = queryBuf;
 318         entityHandlerRequest->obsInfo.action = observeAction;
 319         entityHandlerRequest->obsInfo.obsId = observeID;
 320
 321         if(payload && payloadSize)
 322         {
 323             if(OCParsePayload(&entityHandlerRequest->payload, payload, payloadSize) != OC_STACK_OK)
 324             {
 325                 return OC_STACK_ERROR;
 326             }
 327         }
 328         else
 329         {
 330             entityHandlerRequest->payload = NULL;
 331         }
 332
 333         entityHandlerRequest->numRcvdVendorSpecificHeaderOptions = numVendorOptions;
 334         entityHandlerRequest->rcvdVendorSpecificHeaderOptions = vendorOptions;
 335
 336         return OC_STACK_OK;
 337     }
 338
 339     return OC_STACK_INVALID_PARAM;
 340 }
 341
 342 /**
 343  * Find a server request in the server request list and delete
 344  *
 345  * @param serverRequest - server request to find and delete
 346  */
 347 void FindAndDeleteServerRequest(OCServerRequest * serverRequest)
 348 {
 349     OCServerRequest* tmp;
 350     if(serverRequest)
 351     {
 352         LL_FOREACH(serverRequestList, tmp)
 353         {
 354             if (serverRequest == tmp)
 355             {
 356                 DeleteServerRequest(tmp);
 357                 return;
 358             }
 359         }
 360     }
 361 }
 362
 363 CAResponseResult_t ConvertEHResultToCAResult (OCEntityHandlerResult result)
 364 {
 365     CAResponseResult_t caResult = CA_BAD_REQ;
 366
 367     switch (result)
 368     {
 369         case OC_EH_OK:
 370             caResult = CA_SUCCESS;
 371             break;
 372         case OC_EH_ERROR:
 373             caResult = CA_BAD_REQ;
 374             break;
 375         case OC_EH_RESOURCE_CREATED:
 376             caResult = CA_CREATED;
 377             break;
 378         case OC_EH_RESOURCE_DELETED:
 379             caResult = CA_DELETED;
 380             break;
 381         case OC_EH_SLOW:
 382             caResult = CA_SUCCESS;
 383             break;
 384         case OC_EH_FORBIDDEN:
 385             caResult = CA_UNAUTHORIZED_REQ;
 386             break;
 387         case OC_EH_RESOURCE_NOT_FOUND:
 388             caResult = CA_NOT_FOUND;
 389             break;
 390         default:
 391             caResult = CA_BAD_REQ;
 392             break;
 393     }
 394     return caResult;
 395 }
 396
 397
 398 /**
 399  * Handler function for sending a response from a single resource
 400  *
 401  * @param ehResponse - pointer to the response from the resource
 402  *
 403  * @return
 404  *     OCStackResult
 405  */
 406
 407 OCStackResult HandleSingleResponse(OCEntityHandlerResponse * ehResponse)
 408 {
 409     OCStackResult result = OC_STACK_ERROR;
 410     CAEndpoint_t responseEndpoint = {};
 411     CAResponseInfo_t responseInfo = {};
 412     CAHeaderOption_t* optionsPointer = NULL;
 413
 414     if(!ehResponse || !ehResponse->requestHandle)
 415     {
 416         return OC_STACK_ERROR;
 417     }
 418
 419     OCServerRequest *serverRequest = (OCServerRequest *)ehResponse->requestHandle;
 420
 421     CopyDevAddrToEndpoint(&serverRequest->devAddr, &responseEndpoint);
 422
 423     responseInfo.info.resourceUri = serverRequest->resourceUrl;
 424     responseInfo.result = ConvertEHResultToCAResult(ehResponse->ehResult);
 425
 426     if(serverRequest->notificationFlag && serverRequest->qos == OC_HIGH_QOS)
 427     {
 428         responseInfo.info.type = CA_MSG_CONFIRM;
 429     }
 430     else if(serverRequest->notificationFlag && serverRequest->qos != OC_HIGH_QOS)
 431     {
 432         responseInfo.info.type = CA_MSG_NONCONFIRM;
 433     }
 434     else if(!serverRequest->notificationFlag && !serverRequest->slowFlag &&
 435             serverRequest->qos == OC_HIGH_QOS)
 436     {
 437         responseInfo.info.type = CA_MSG_ACKNOWLEDGE;
 438     }
 439     else if(!serverRequest->notificationFlag && serverRequest->slowFlag &&
 440             serverRequest->qos == OC_HIGH_QOS)
 441     {
 442         responseInfo.info.type = CA_MSG_CONFIRM;
 443     }
 444     else if(!serverRequest->notificationFlag)
 445     {
 446         responseInfo.info.type = CA_MSG_NONCONFIRM;
 447     }
 448
 449     responseInfo.info.messageId = serverRequest->coapID;
 450     responseInfo.info.token = (CAToken_t)OICMalloc(CA_MAX_TOKEN_LEN+1);
 451     if (!responseInfo.info.token)
 452     {
 453         OC_LOG(FATAL, TAG, "Response Info Token is NULL");
 454         return result;
 455     }
 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("options is NULL"));
 478             OICFree(responseInfo.info.token);
 479             return OC_STACK_NO_MEMORY;
 480         }
 481
 482         optionsPointer = responseInfo.info.options;
 483
 484         // TODO: This exposes CoAP specific details.  At some point, this should be
 485         // re-factored and handled in the CA layer.
 486         if(serverRequest->observeResult == OC_STACK_OK)
 487         {
 488             responseInfo.info.options[0].protocolID = CA_COAP_ID;
 489             responseInfo.info.options[0].optionID = COAP_OPTION_OBSERVE;
 490             responseInfo.info.options[0].optionLength = sizeof(uint32_t);
 491             memcpy(responseInfo.info.options[0].optionData,
 492                     &(serverRequest->observationOption), sizeof(uint32_t));
 493
 494             // Point to the next header option before copying vender specific header options
 495             optionsPointer += 1;
 496         }
 497
 498         if (ehResponse->numSendVendorSpecificHeaderOptions)
 499         {
 500             memcpy(optionsPointer, ehResponse->sendVendorSpecificHeaderOptions,
 501                             sizeof(OCHeaderOption) *
 502                             ehResponse->numSendVendorSpecificHeaderOptions);
 503         }
 504     }
 505     else
 506     {
 507         responseInfo.info.options = NULL;
 508     }
 509
 510     // Put the JSON prefix and suffix around the payload
 511     if(ehResponse->payload)
 512     {
 513         OCStackResult result;
 514         if((result = OCConvertPayload(ehResponse->payload, &responseInfo.info.payload,
 515                     &responseInfo.info.payloadSize))
 516                 != OC_STACK_OK)
 517         {
 518             OC_LOG(ERROR, TAG, "Error converting payload");
 519             return result;
 520         }
 521
 522         if(responseInfo.info.payloadSize > MAX_RESPONSE_LENGTH)
 523         {
 524             OICFree(responseInfo.info.payload);
 525             OC_LOG(ERROR, TAG, "Payload too long!");
 526             return OC_STACK_INVALID_PARAM;
 527         }
 528     }
 529     else
 530     {
 531         responseInfo.info.payload = NULL;
 532         responseInfo.info.payloadSize = 0;
 533     }
 534
 535     #ifdef WITH_PRESENCE
 536     //TODO: Add other connectivity types to CAConnTypes[] when enabled
 537     CATransportAdapter_t CAConnTypes[] = {CA_ADAPTER_IP};
 538     const char * connTypes[] = {"IP"};
 539     int size = sizeof(CAConnTypes)/ sizeof(CATransportAdapter_t);
 540     CATransportAdapter_t adapter = responseEndpoint.adapter;
 541     CAResult_t caResult = CA_STATUS_FAILED;
 542     result = OC_STACK_OK;
 543
 544     // Default adapter, try to send response out on all adapters.
 545     if (adapter == CA_DEFAULT_ADAPTER)
 546     {
 547         adapter =
 548             (CATransportAdapter_t)(CA_ADAPTER_IP | CA_ADAPTER_GATT_BTLE | CA_ADAPTER_RFCOMM_BTEDR);
 549     }
 550
 551     for(int i = 0; i < size; i++ )
 552     {
 553         responseEndpoint.adapter = (CATransportAdapter_t)(adapter & CAConnTypes[i]);
 554         if(responseEndpoint.adapter)
 555         {
 556             //The result is set to OC_STACK_OK only if CASendResponse succeeds in sending the
 557             //response on all the n/w interfaces else it is set to OC_STACK_ERROR
 558             caResult = CASendResponse(&responseEndpoint, &responseInfo);
 559             if(caResult != CA_STATUS_OK)
 560             {
 561                 OC_LOG_V(ERROR, TAG, "CASendResponse failed on %s", connTypes[i]);
 562                 result = CAResultToOCResult(caResult);
 563             }
 564             else
 565             {
 566                 OC_LOG_V(INFO, TAG, "CASendResponse succeeded on %s", connTypes[i]);
 567             }
 568         }
 569     }
 570     #else
 571     CAResult_t caResult = CASendResponse(&responseEndpoint, &responseInfo);
 572     if(caResult != CA_STATUS_OK)
 573     {
 574         OC_LOG(ERROR, TAG, PCF("CASendResponse failed"));
 575         result = CAResultToOCResult(caResult);
 576     }
 577     else
 578     {
 579         result = OC_STACK_OK;
 580     }
 581     #endif
 582
 583     OICFree(responseInfo.info.payload);
 584     OICFree(responseInfo.info.token);
 585     OICFree(responseInfo.info.options);
 586     //Delete the request
 587     FindAndDeleteServerRequest(serverRequest);
 588     return result;
 589 }
 590
 591 /**
 592  * Handler function for sending a response from multiple resources, such as a collection.
 593  * Aggregates responses from multiple resource until all responses are received then sends the
 594  * concatenated response
 595  *
 596  * TODO: Need to add a timeout in case a (remote?) resource does not respond
 597  *
 598  * @param ehResponse - pointer to the response from the resource
 599  *
 600  * @return
 601  *     OCStackResult
 602  */
 603 OCStackResult HandleAggregateResponse(OCEntityHandlerResponse * ehResponse)
 604 {
 605     OCStackResult stackRet = OC_STACK_ERROR;
 606     OCServerRequest * serverRequest = NULL;
 607     OCServerResponse * serverResponse = NULL;
 608
 609     if(!ehResponse || !ehResponse->payload)
 610     {
 611         OC_LOG(ERROR, TAG, PCF("HandleAggregateResponse invalid parameters"));
 612         return OC_STACK_INVALID_PARAM;
 613     }
 614
 615     OC_LOG(INFO, TAG, "Inside HandleAggregateResponse");
 616
 617     serverRequest = GetServerRequestUsingHandle((OCServerRequest *)ehResponse->requestHandle);
 618     serverResponse = GetServerResponseUsingHandle((OCServerRequest *)ehResponse->requestHandle);
 619
 620     if(serverRequest)
 621     {
 622         if(!serverResponse)
 623         {
 624             OC_LOG(INFO, TAG, PCF("This is the first response fragment"));
 625             stackRet = AddServerResponse(&serverResponse, ehResponse->requestHandle);
 626             if (OC_STACK_OK != stackRet)
 627             {
 628                 OC_LOG(ERROR, TAG, PCF("Error adding server response"));
 629                 return stackRet;
 630             }
 631             VERIFY_NON_NULL(serverResponse);
 632         }
 633
 634         if(serverResponse->payload->type != PAYLOAD_TYPE_REPRESENTATION ||
 635                 ehResponse->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 636         {
 637             stackRet = OC_STACK_ERROR;
 638             OC_LOG(ERROR, TAG, PCF("Error adding payload, as it was the incorrect type"));
 639             goto exit;
 640         }
 641
 642         OCRepPayloadAppend((OCRepPayload*)serverResponse->payload,
 643                 (OCRepPayload*)ehResponse->payload);
 644
 645         (serverRequest->numResponses)--;
 646
 647         if(serverRequest->numResponses == 0)
 648         {
 649             OC_LOG(INFO, TAG, PCF("This is the last response fragment"));
 650             ehResponse->payload = serverResponse->payload;
 651             stackRet = HandleSingleResponse(ehResponse);
 652             //Delete the request and response
 653             FindAndDeleteServerRequest(serverRequest);
 654             FindAndDeleteServerResponse(serverResponse);
 655         }
 656         else
 657         {
 658             OC_LOG(INFO, TAG, PCF("More response fragments to come"));
 659             stackRet = OC_STACK_OK;
 660         }
 661     }
 662 exit:
 663     return stackRet;
 664 }
 665