resource/csdk/security/src/pstatresource.c

   1 //******************************************************************
   2 //
   3 // Copyright 2015 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
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include "ocstack.h"
  25 #include "oic_malloc.h"
  26 #include "ocpayload.h"
  27 #include "payload_logging.h"
  28 #include "resourcemanager.h"
  29 #include "pstatresource.h"
  30 #include "doxmresource.h"
  31 #include "psinterface.h"
  32 #include "srmresourcestrings.h"
  33 #include "srmutility.h"
  34
  35 #define TAG  "SRM-PSTAT"
  36
  37 /** Default cbor payload size. This value is increased in case of CborErrorOutOfMemory.
  38  * The value of payload size is increased until reaching below max cbor size. */
  39 static const uint16_t CBOR_SIZE = 512;
  40
  41 // Max cbor size payload.
  42 static const uint16_t CBOR_MAX_SIZE = 4400;
  43
  44 // PSTAT Map size - Number of mandatory items
  45 static const uint8_t PSTAT_MAP_SIZE = 7;
  46
  47 static OicSecDpom_t gSm = SINGLE_SERVICE_CLIENT_DRIVEN;
  48 static OicSecPstat_t gDefaultPstat =
  49 {
  50     false,                                    // bool isOwned
  51     (OicSecDpm_t)(BOOTSTRAP_SERVICE | SECURITY_MANAGEMENT_SERVICES |
  52     PROVISION_CREDENTIALS | PROVISION_ACLS),   // OicSecDpm_t cm
  53     (OicSecDpm_t)(TAKE_OWNER | BOOTSTRAP_SERVICE | SECURITY_MANAGEMENT_SERVICES |
  54     PROVISION_CREDENTIALS | PROVISION_ACLS),   // OicSecDpm_t tm
  55     {.id = {0}},                              // OicUuid_t deviceID
  56     SINGLE_SERVICE_CLIENT_DRIVEN,             // OicSecDpom_t om */
  57     1,                                        // the number of elts in Sms
  58     &gSm,                                     // OicSecDpom_t *sm
  59     0,                                        // uint16_t commitHash
  60     {.id = {0}},                              // OicUuid_t rownerID
  61 };
  62
  63 static OicSecPstat_t    *gPstat = NULL;
  64
  65 static OCResourceHandle gPstatHandle = NULL;
  66
  67 void DeletePstatBinData(OicSecPstat_t* pstat)
  68 {
  69     if (pstat)
  70     {
  71         //Clean 'supported modes' field
  72         OICFree(pstat->sm);
  73
  74         //Clean pstat itself
  75         OICFree(pstat);
  76     }
  77 }
  78
  79 OCStackResult PstatToCBORPayload(const OicSecPstat_t *pstat, uint8_t **payload, size_t *size)
  80 {
  81     if (NULL == pstat || NULL == payload || NULL != *payload || NULL == size)
  82     {
  83         return OC_STACK_INVALID_PARAM;
  84     }
  85
  86     size_t cborLen = *size;
  87     if (0 == cborLen)
  88     {
  89         cborLen = CBOR_SIZE;
  90     }
  91
  92     *payload = NULL;
  93     *size = 0;
  94
  95     OCStackResult ret = OC_STACK_ERROR;
  96
  97     CborEncoder encoder = { {.ptr = NULL }, .end = 0 };
  98     CborEncoder pstatMap = { {.ptr = NULL }, .end = 0 };
  99     char* strUuid = NULL;
 100
 101     int64_t cborEncoderResult = CborNoError;
 102
 103     uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen);
 104     VERIFY_NON_NULL(TAG, outPayload, ERROR);
 105     cbor_encoder_init(&encoder, outPayload, cborLen, 0);
 106
 107     cborEncoderResult = cbor_encoder_create_map(&encoder, &pstatMap, PSTAT_MAP_SIZE);
 108     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Pstat Map.");
 109
 110     cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_ISOP_NAME,
 111         strlen(OIC_JSON_ISOP_NAME));
 112     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ISOP Name Tag.");
 113     cborEncoderResult = cbor_encode_boolean(&pstatMap, pstat->isOp);
 114     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ISOP Name Value.");
 115
 116     cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_DEVICE_ID_NAME,
 117         strlen(OIC_JSON_DEVICE_ID_NAME));
 118     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Device Id Tag.");
 119     ret = ConvertUuidToStr(&pstat->deviceID, &strUuid);
 120     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret , ERROR);
 121     cborEncoderResult = cbor_encode_text_string(&pstatMap, strUuid, strlen(strUuid));
 122     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Device Id Value.");
 123     OICFree(strUuid);
 124     strUuid = NULL;
 125
 126     cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_CM_NAME,
 127         strlen(OIC_JSON_CM_NAME));
 128     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CM Name Tag.");
 129     cborEncoderResult = cbor_encode_int(&pstatMap, pstat->cm);
 130     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CM Name Value.");
 131
 132     cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_TM_NAME,
 133         strlen(OIC_JSON_TM_NAME));
 134     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding TM Name Tag.");
 135     cborEncoderResult = cbor_encode_int(&pstatMap, pstat->tm);
 136     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding TM Name Value.");
 137
 138     cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_OM_NAME,
 139         strlen(OIC_JSON_OM_NAME));
 140     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding OM Name Tag.");
 141     cborEncoderResult = cbor_encode_int(&pstatMap, pstat->om);
 142     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding OM Name Value.");
 143
 144     cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_SM_NAME,
 145         strlen(OIC_JSON_SM_NAME));
 146     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SM Name Tag.");
 147     cborEncoderResult = cbor_encode_int(&pstatMap, pstat->sm[0]);
 148     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SM Name Value.");
 149
 150     cborEncoderResult = cbor_encode_text_string(&pstatMap, OIC_JSON_ROWNERID_NAME,
 151         strlen(OIC_JSON_ROWNERID_NAME));
 152     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ROwner Id Tag.");
 153     ret = ConvertUuidToStr(&pstat->rownerID, &strUuid);
 154     VERIFY_SUCCESS(TAG, OC_STACK_OK == ret , ERROR);
 155     cborEncoderResult = cbor_encode_text_string(&pstatMap, strUuid, strlen(strUuid));
 156     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ROwner Id Value.");
 157     OICFree(strUuid);
 158     strUuid = NULL;
 159
 160     cborEncoderResult = cbor_encoder_close_container(&encoder, &pstatMap);
 161     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Closing PSTAT Map.");
 162
 163     if (CborNoError == cborEncoderResult)
 164     {
 165         *size = encoder.ptr - outPayload;
 166         *payload = outPayload;
 167         ret = OC_STACK_OK;
 168     }
 169 exit:
 170     if ((CborErrorOutOfMemory == cborEncoderResult) && (cborLen < CBOR_MAX_SIZE))
 171     {
 172         // reallocate and try again!
 173         OICFree(outPayload);
 174         // Since the allocated initial memory failed, double the memory.
 175         cborLen += encoder.ptr - encoder.end;
 176         cborEncoderResult = CborNoError;
 177         ret = PstatToCBORPayload(pstat, payload, &cborLen);
 178         if (OC_STACK_OK == ret)
 179         {
 180             *size = cborLen;
 181         }
 182     }
 183
 184     if ((CborNoError != cborEncoderResult) || (OC_STACK_OK != ret))
 185     {
 186         OICFree(outPayload);
 187         outPayload = NULL;
 188         *payload = NULL;
 189         *size = 0;
 190         ret = OC_STACK_ERROR;
 191     }
 192
 193     return ret;
 194 }
 195
 196 OCStackResult CBORPayloadToPstat(const uint8_t *cborPayload, const size_t size,
 197                                  OicSecPstat_t **secPstat)
 198 {
 199     if (NULL == cborPayload || NULL == secPstat || NULL != *secPstat)
 200     {
 201         return OC_STACK_INVALID_PARAM;
 202     }
 203
 204     OCStackResult ret = OC_STACK_ERROR;
 205     *secPstat = NULL;
 206
 207     CborValue pstatCbor;
 208     CborParser parser;
 209     CborError cborFindResult = CborNoError;
 210     char *strUuid = NULL;
 211     int cborLen = size;
 212     size_t len = 0;
 213     if (0 == size)
 214     {
 215         cborLen = CBOR_SIZE;
 216     }
 217     cbor_parser_init(cborPayload, cborLen, 0, &parser, &pstatCbor);
 218     CborValue pstatMap = { .parser = NULL };
 219
 220     OicSecPstat_t *pstat = NULL;
 221     cborFindResult = cbor_value_enter_container(&pstatCbor, &pstatMap);
 222     VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PSTAT Map.");
 223
 224     pstat = (OicSecPstat_t *)OICCalloc(1, sizeof(OicSecPstat_t));
 225     VERIFY_NON_NULL(TAG, pstat, ERROR);
 226
 227     cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_ISOP_NAME, &pstatMap);
 228     if (CborNoError == cborFindResult && cbor_value_is_boolean(&pstatMap))
 229     {
 230         cborFindResult = cbor_value_get_boolean(&pstatMap, &pstat->isOp);
 231         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding isOp Value.");
 232     }
 233
 234     cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_DEVICE_ID_NAME, &pstatMap);
 235     if (CborNoError == cborFindResult && cbor_value_is_text_string(&pstatMap))
 236     {
 237         cborFindResult = cbor_value_dup_text_string(&pstatMap, &strUuid , &len, NULL);
 238         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Device Id Value.");
 239         ret = ConvertStrToUuid(strUuid , &pstat->deviceID);
 240         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 241         OICFree(strUuid );
 242         strUuid  = NULL;
 243     }
 244
 245     cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_CM_NAME, &pstatMap);
 246     if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap))
 247     {
 248         cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->cm);
 249         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding CM.");
 250     }
 251
 252     cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_TM_NAME, &pstatMap);
 253     if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap))
 254     {
 255         cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->tm);
 256         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding TM.");
 257     }
 258
 259     cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_OM_NAME, &pstatMap);
 260     if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap))
 261     {
 262         cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->om);
 263         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding OM.");
 264     }
 265
 266     cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_SM_NAME, &pstatMap);
 267     if (CborNoError == cborFindResult && cbor_value_is_integer(&pstatMap))
 268     {
 269         pstat->smLen = 1;
 270         pstat->sm = (OicSecDpom_t*)OICCalloc(pstat->smLen, sizeof(OicSecDpom_t));
 271         cborFindResult = cbor_value_get_int(&pstatMap, (int *) &pstat->sm[0]);
 272         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding SM.");
 273
 274     }
 275
 276     cborFindResult = cbor_value_map_find_value(&pstatCbor, OIC_JSON_ROWNERID_NAME, &pstatMap);
 277     if (CborNoError == cborFindResult && cbor_value_is_text_string(&pstatMap))
 278     {
 279         cborFindResult = cbor_value_dup_text_string(&pstatMap, &strUuid , &len, NULL);
 280         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding ROwner Id Value.");
 281         ret = ConvertStrToUuid(strUuid , &pstat->rownerID);
 282         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 283         OICFree(strUuid );
 284         strUuid  = NULL;
 285     }
 286
 287     *secPstat = pstat;
 288     ret = OC_STACK_OK;
 289
 290 exit:
 291     if (CborNoError != cborFindResult)
 292     {
 293         OIC_LOG(ERROR, TAG, "CBORPayloadToPstat failed");
 294         DeletePstatBinData(pstat);
 295         pstat = NULL;
 296         *secPstat = NULL;
 297         ret = OC_STACK_ERROR;
 298     }
 299
 300     return ret;
 301 }
 302
 303 /**
 304  * Function to update persistent storage
 305  */
 306 static bool UpdatePersistentStorage(OicSecPstat_t *pstat)
 307 {
 308     bool bRet = false;
 309
 310     size_t size = 0;
 311     uint8_t *cborPayload = NULL;
 312     OCStackResult ret = PstatToCBORPayload(pstat, &cborPayload, &size);
 313     if (OC_STACK_OK == ret)
 314     {
 315         if (OC_STACK_OK == UpdateSecureResourceInPS(OIC_JSON_PSTAT_NAME, cborPayload, size))
 316         {
 317             bRet = true;
 318         }
 319         OICFree(cborPayload);
 320     }
 321
 322     return bRet;
 323 }
 324
 325
 326 /**
 327  * The entity handler determines how to process a GET request.
 328  */
 329 static OCEntityHandlerResult HandlePstatGetRequest (const OCEntityHandlerRequest * ehRequest)
 330 {
 331     OIC_LOG(INFO, TAG, "HandlePstatGetRequest  processing GET request");
 332
 333     // Convert ACL data into CBOR for transmission
 334     size_t size = 0;
 335     uint8_t *payload = NULL;
 336     OCStackResult res = PstatToCBORPayload(gPstat, &payload, &size);
 337
 338     // A device should always have a default pstat. Therefore, payload should never be NULL.
 339     OCEntityHandlerResult ehRet = (res == OC_STACK_OK) ? OC_EH_OK : OC_EH_ERROR;
 340
 341     // Send response payload to request originator
 342     SendSRMCBORResponse(ehRequest, ehRet, payload, size);
 343     OICFree(payload);
 344     return ehRet;
 345 }
 346
 347 /**
 348  * The entity handler determines how to process a POST request.
 349  * Per the REST paradigm, POST can also be used to update representation of existing
 350  * resource or create a new resource.
 351  * For pstat, it updates only tm and om.
 352  */
 353 static OCEntityHandlerResult HandlePstatPutRequest(const OCEntityHandlerRequest *ehRequest)
 354 {
 355     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 356     OIC_LOG(INFO, TAG, "HandlePstatPutRequest  processing PUT request");
 357     OicSecPstat_t *pstat = NULL;
 358
 359     if (ehRequest->resource)
 360     {
 361         uint8_t *payload = ((OCSecurityPayload *) ehRequest->payload)->securityData1;
 362         size_t size = ((OCSecurityPayload *) ehRequest->payload)->payloadSize;
 363         VERIFY_NON_NULL(TAG, payload, ERROR);
 364
 365         OCStackResult ret = CBORPayloadToPstat(payload, size, &pstat);
 366         OICFree(payload);
 367         VERIFY_NON_NULL(TAG, pstat, ERROR);
 368         if (OC_STACK_OK == ret)
 369         {
 370             if (false == (pstat->cm & TAKE_OWNER) && false == pstat->isOp)
 371             {
 372                 gPstat->cm = pstat->cm;
 373                 OIC_LOG (INFO, TAG, "State changed to Ready for Provisioning");
 374             }
 375             else if (false == (pstat->cm & TAKE_OWNER) && true == pstat->isOp)
 376             {
 377                 gPstat->isOp =pstat->isOp;
 378                 OIC_LOG (INFO, TAG, "State changed to Ready for Normal Operation");
 379             }
 380             else
 381             {
 382                 OIC_LOG(DEBUG, TAG, "Invalid Device provisionig state");
 383             }
 384             if (pstat->om != MULTIPLE_SERVICE_SERVER_DRIVEN && gPstat)
 385             {
 386                 /*
 387                  * Check if the operation mode is in the supported provisioning services
 388                  * operation mode list.
 389                  */
 390                 for (size_t i=0; i< gPstat->smLen; i++)
 391                 {
 392                     if(gPstat->sm[i] == pstat->om)
 393                     {
 394                         gPstat->om = pstat->om;
 395                         break;
 396                     }
 397                 }
 398             }
 399             // Convert pstat data into CBOR for update to persistent storage
 400             if (UpdatePersistentStorage(gPstat))
 401             {
 402                 ehRet = OC_EH_OK;
 403             }
 404         }
 405     }
 406  exit:
 407     if(OC_EH_OK != ehRet)
 408     {
 409         /*
 410           * If some error is occured while ownership transfer,
 411           * ownership transfer related resource should be revert back to initial status.
 412           */
 413         RestoreDoxmToInitState();
 414         RestorePstatToInitState();
 415     }
 416
 417     //Send payload to request originator
 418     if(OC_STACK_OK != SendSRMCBORResponse(ehRequest, ehRet, NULL, 0))
 419     {
 420         OIC_LOG (ERROR, TAG, "SendSRMResponse failed in HandlePstatPostRequest");
 421     }
 422     DeletePstatBinData(pstat);
 423     return ehRet;
 424 }
 425
 426 /**
 427  * This internal method is the entity handler for pstat resources.
 428  */
 429  OCEntityHandlerResult PstatEntityHandler(OCEntityHandlerFlag flag,
 430                                           OCEntityHandlerRequest * ehRequest,
 431                                           void *callbackParam)
 432 {
 433     (void)callbackParam;
 434     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 435     // This method will handle REST request (GET/POST) for /oic/sec/pstat
 436     if (flag & OC_REQUEST_FLAG)
 437     {
 438         OIC_LOG(INFO, TAG, "Flag includes OC_REQUEST_FLAG");
 439         switch (ehRequest->method)
 440         {
 441             case OC_REST_GET:
 442                 ehRet = HandlePstatGetRequest(ehRequest);
 443                 break;
 444             case OC_REST_PUT:
 445                 ehRet = HandlePstatPutRequest(ehRequest);
 446                 break;
 447             default:
 448                 ehRet = OC_EH_ERROR;
 449                 SendSRMCBORResponse(ehRequest, ehRet, NULL, 0);
 450                 break;
 451         }
 452     }
 453     return ehRet;
 454 }
 455
 456 /**
 457  * This internal method is used to create '/oic/sec/pstat' resource.
 458  */
 459  OCStackResult CreatePstatResource()
 460 {
 461     OCStackResult ret = OCCreateResource(&gPstatHandle,
 462                                          OIC_RSRC_TYPE_SEC_PSTAT,
 463                                          OIC_MI_DEF,
 464                                          OIC_RSRC_PSTAT_URI,
 465                                          PstatEntityHandler,
 466                                          NULL,
 467                                          OC_RES_PROP_NONE);
 468
 469     if (OC_STACK_OK != ret)
 470     {
 471         OIC_LOG(FATAL, TAG, "Unable to instantiate pstat resource");
 472         DeInitPstatResource();
 473     }
 474     return ret;
 475 }
 476
 477 /**
 478  * Get the default value.
 479  *
 480  * @return the gDefaultPstat pointer.
 481  */
 482 static OicSecPstat_t* GetPstatDefault()
 483 {
 484     return &gDefaultPstat;
 485 }
 486
 487 OCStackResult InitPstatResource()
 488 {
 489     OCStackResult ret = OC_STACK_ERROR;
 490
 491     // Read Pstat resource from PS
 492     uint8_t *data = NULL;
 493     size_t size = 0;
 494     ret = GetSecureVirtualDatabaseFromPS(OIC_JSON_PSTAT_NAME, &data, &size);
 495     // If database read failed
 496     if (OC_STACK_OK != ret)
 497     {
 498         OIC_LOG (DEBUG, TAG, "ReadSVDataFromPS failed");
 499     }
 500     if (data)
 501     {
 502         // Read ACL resource from PS
 503         ret = CBORPayloadToPstat(data, size, &gPstat);
 504         OICFree(data);
 505     }
 506     /*
 507      * If SVR database in persistent storage got corrupted or
 508      * is not available for some reason, a default pstat is created
 509      * which allows user to initiate pstat provisioning again.
 510      */
 511     if ((OC_STACK_OK != ret) || !gPstat)
 512     {
 513         gPstat = GetPstatDefault();
 514     }
 515     VERIFY_NON_NULL(TAG, gPstat, FATAL);
 516
 517     // Instantiate 'oic.sec.pstat'
 518     ret = CreatePstatResource();
 519
 520 exit:
 521     if (OC_STACK_OK != ret)
 522     {
 523         DeInitPstatResource();
 524     }
 525     return ret;
 526 }
 527
 528 OCStackResult DeInitPstatResource()
 529 {
 530     if (gPstat != &gDefaultPstat)
 531     {
 532         DeletePstatBinData(gPstat);
 533         gPstat = NULL;
 534     }
 535     return OCDeleteResource(gPstatHandle);
 536 }
 537
 538 /**
 539  * Function to restore pstat resurce to initial status.
 540  * This function will use in case of error while ownership transfer
 541  */
 542 void RestorePstatToInitState()
 543 {
 544     if(gPstat)
 545     {
 546         OIC_LOG(INFO, TAG, "PSTAT resource will revert back to initial status.");
 547
 548         gPstat->cm = (OicSecDpm_t)(gPstat->cm | TAKE_OWNER);
 549         gPstat->tm = (OicSecDpm_t)(gPstat->tm & (~TAKE_OWNER));
 550         gPstat->om = SINGLE_SERVICE_CLIENT_DRIVEN;
 551         if(gPstat->sm && 0 < gPstat->smLen)
 552         {
 553             gPstat->sm[0] = SINGLE_SERVICE_CLIENT_DRIVEN;
 554         }
 555
 556         if (!UpdatePersistentStorage(gPstat))
 557         {
 558             OIC_LOG(ERROR, TAG, "Failed to revert PSTAT in persistent storage");
 559         }
 560     }
 561 }