resource/csdk/security/src/dpairingresource.c

   1 /* *****************************************************************
   2  *
   3  * Copyright 2016 Samsung Electronics 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 #include "ocstack.h"
  24 #include "logger.h"
  25 #include "oic_malloc.h"
  26 #include "oic_string.h"
  27 #include "cJSON.h"
  28 #include "base64.h"
  29 #include "resourcemanager.h"
  30 #include "dpairingresource.h"
  31 #include "psinterface.h"
  32 #include "utlist.h"
  33 #include "srmresourcestrings.h"
  34 #include "cainterface.h"
  35 #include "doxmresource.h"
  36 #include "pconfresource.h"
  37 #include "credresource.h"
  38 #include "aclresource.h"
  39 #include "srmutility.h"
  40 #include "ocserverrequest.h"
  41 #include "ocpayloadcbor.h"
  42 #include "ocpayload.h"
  43 #include "payload_logging.h"
  44 #include <stdlib.h>
  45 #ifdef WITH_ARDUINO
  46 #include <string.h>
  47 #else
  48 #include <strings.h>
  49 #endif
  50
  51 #ifdef __WITH_DTLS__
  52 #include "global.h"
  53 #endif
  54
  55 #define TAG  "SRM-DPAIRING"
  56
  57 /** Default cbor payload size. This value is increased in case of CborErrorOutOfMemory.
  58  * The value of payload size is increased until reaching belox max cbor size. */
  59 static const uint16_t CBOR_SIZE = 1024;
  60
  61 /** Max cbor size payload. */
  62 static const uint16_t CBOR_MAX_SIZE = 4400;
  63
  64 /** DOXM Map size - Number of mandatory items. */
  65 static const uint8_t DPAIR_MAP_SIZE = 3;
  66
  67 static OicSecDpairing_t     *gDpair = NULL;
  68 static OCResourceHandle   gDpairHandle = NULL;
  69 static OicSecDpairing_t      gDefaultDpair =
  70 {
  71     PRM_NOT_ALLOWED,       /* OicSecPrm_t spm */
  72     {.id = {0}},                   /* OicUuid_t pdeviceID */
  73     {.id = {0}},                   /* OicUuid_t rowner */
  74 };
  75
  76 void DeleteDpairingBinData(OicSecDpairing_t* dpair)
  77 {
  78     if (dpair)
  79     {
  80         //Clean dpairing itself
  81         OICFree(dpair);
  82     }
  83 }
  84
  85 /**
  86  * Get the default value.
  87  * @retval  the gDefaultDpair pointer;
  88  */
  89 static OicSecDpairing_t* GetDpairingDefault()
  90 {
  91     OIC_LOG (DEBUG, TAG, "GetDpairingDefault");
  92
  93     return &gDefaultDpair;
  94 }
  95
  96 /**
  97  * This method is used by SRM to retrieve Dpairing resource data..
  98  */
  99 void SetDpairingResourceOwner(OicUuid_t *rowner)
 100 {
 101     OIC_LOG (DEBUG, TAG, "SetDpairingResourceOwner");
 102     if (gDpair)
 103     {
 104         memcpy(&gDpair->rownerID, rowner, sizeof(OicUuid_t));
 105     }
 106 }
 107
 108 #ifdef __WITH_DTLS__
 109 /**
 110  * Function to save PairingPSK.
 111  *
 112  * @param[in] endpoint   current endpoint.
 113  * @param[in] peerDevID   peer device indentitiy.
 114  * @param[in] isPairingServer   indicate if it generates PairingPSK for server or client.
 115  *
 116  * @return  OC_STACK_OK on success
 117  */
 118 OCStackResult SavePairingPSK(OCDevAddr *endpoint,
 119             OicUuid_t *peerDevID, OicUuid_t *owner, bool isPairingServer)
 120 {
 121     OIC_LOG(DEBUG, TAG, "IN SavePairingPSK");
 122
 123     if(NULL == endpoint || NULL == peerDevID || NULL == owner)
 124     {
 125         OIC_LOG_V(ERROR, TAG, "Invalid Input parameters in [%s]\n", __FUNCTION__);
 126         return OC_STACK_INVALID_PARAM;
 127     }
 128
 129     OCStackResult res = OC_STACK_ERROR;
 130
 131     OicUuid_t ptDeviceID = {.id={0}};
 132     if (OC_STACK_OK != GetDoxmDeviceID(&ptDeviceID))
 133     {
 134         OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
 135         return res;
 136     }
 137
 138     uint8_t pairingPSK[OWNER_PSK_LENGTH_128] = {0};
 139     OicSecKey_t pairingKey = {pairingPSK, OWNER_PSK_LENGTH_128};
 140
 141     //Generating PairingPSK using OwnerPSK scheme
 142     CAResult_t pskRet = CAGenerateOwnerPSK((const CAEndpoint_t *)endpoint,
 143             (uint8_t *)OIC_RSRC_TYPE_SEC_DPAIRING,
 144             strlen(OIC_RSRC_TYPE_SEC_DPAIRING),
 145             (isPairingServer ? ptDeviceID.id : peerDevID->id), sizeof(OicUuid_t), // server
 146             (isPairingServer ? peerDevID->id : ptDeviceID.id), sizeof(OicUuid_t), // client
 147             pairingPSK, OWNER_PSK_LENGTH_128);
 148
 149     if (CA_STATUS_OK == pskRet)
 150     {
 151         OIC_LOG(INFO, TAG, "pairingPSK dump:\n");
 152         OIC_LOG_BUFFER(INFO, TAG, pairingPSK, OWNER_PSK_LENGTH_128);
 153         //Generating new credential for direct-pairing client
 154
 155         OicSecCred_t *cred = GenerateCredential(peerDevID,
 156                 SYMMETRIC_PAIR_WISE_KEY, NULL,
 157                 &pairingKey, owner);
 158         VERIFY_NON_NULL(TAG, cred, ERROR);
 159
 160         res = AddCredential(cred);
 161         if(res != OC_STACK_OK)
 162         {
 163             DeleteCredList(cred);
 164             return res;
 165         }
 166     }
 167     else
 168     {
 169         OIC_LOG(ERROR, TAG, "CAGenerateOwnerPSK failed");
 170     }
 171
 172     OIC_LOG(DEBUG, TAG, "OUT SavePairingPSK");
 173 exit:
 174     return res;
 175 }
 176 #endif // __WITH_DTLS__
 177
 178 OCStackResult DpairingToCBORPayload(const OicSecDpairing_t *dpair, uint8_t **payload, size_t *size)
 179 {
 180     if (NULL == dpair || NULL == payload || NULL != *payload || NULL == size)
 181     {
 182         return OC_STACK_INVALID_PARAM;
 183     }
 184
 185     size_t cborLen = *size;
 186     if (0 == cborLen)
 187     {
 188         cborLen = CBOR_SIZE;
 189     }
 190
 191     *payload = NULL;
 192     *size = 0;
 193
 194     OCStackResult ret = OC_STACK_ERROR;
 195
 196     CborEncoder encoder;
 197     CborEncoder dpairMap;
 198
 199     int64_t cborEncoderResult = CborNoError;
 200     uint8_t mapSize = DPAIR_MAP_SIZE;
 201
 202     uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen);
 203     VERIFY_NON_NULL(TAG, outPayload, ERROR);
 204     cbor_encoder_init(&encoder, outPayload, cborLen, 0);
 205
 206     cborEncoderResult = cbor_encoder_create_map(&encoder, &dpairMap, mapSize);
 207     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Creating DPAIRING Map");
 208
 209     //spm -- Mandatory
 210     cborEncoderResult = cbor_encode_text_string(&dpairMap, OIC_JSON_SPM_NAME,
 211         strlen(OIC_JSON_SPM_NAME));
 212     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SPM name tag");
 213     cborEncoderResult = cbor_encode_int(&dpairMap, dpair->spm);
 214     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SPM value");
 215
 216     //PDEVICEID -- Mandatory
 217     cborEncoderResult = cbor_encode_text_string(&dpairMap, OIC_JSON_PDEVICE_ID_NAME,
 218         strlen(OIC_JSON_PDEVICE_ID_NAME));
 219     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PDeviceID tag");
 220     {
 221         char *deviceId = NULL;
 222         ret = ConvertUuidToStr(&dpair->pdeviceID, &deviceId);
 223         VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
 224         cborEncoderResult = cbor_encode_text_string(&dpairMap, deviceId, strlen(deviceId));
 225         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to encode PDeviceID value");
 226         OICFree(deviceId);
 227     }
 228
 229     //ROWNER -- Mandatory
 230     {
 231         char *rowner = NULL;
 232         cborEncoderResult = cbor_encode_text_string(&dpairMap, OIC_JSON_ROWNERID_NAME,
 233             strlen(OIC_JSON_ROWNERID_NAME));
 234         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ROWNER tag");
 235         ret = ConvertUuidToStr(&dpair->rownerID, &rowner);
 236         VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
 237         cborEncoderResult = cbor_encode_text_string(&dpairMap, rowner, strlen(rowner));
 238         VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding Rowner ID value");
 239         OICFree(rowner);
 240     }
 241
 242     cborEncoderResult = cbor_encoder_close_container(&encoder, &dpairMap);
 243     VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed to close dpairMap");
 244
 245      if (CborNoError == cborEncoderResult)
 246     {
 247         *size = encoder.ptr - outPayload;
 248         *payload = outPayload;
 249         ret = OC_STACK_OK;
 250     }
 251
 252 exit:
 253     if ((CborErrorOutOfMemory == cborEncoderResult) && (cborLen < CBOR_MAX_SIZE))
 254     {
 255        // reallocate and try again!
 256        OICFree(outPayload);
 257        // Since the allocated initial memory failed, double the memory.
 258        cborLen += encoder.ptr - encoder.end;
 259        cborEncoderResult = CborNoError;
 260        ret = DpairingToCBORPayload(dpair, payload, &cborLen);
 261        *size = cborLen;
 262     }
 263
 264     if ((CborNoError != cborEncoderResult) || (OC_STACK_OK != ret))
 265     {
 266        OICFree(outPayload);
 267        outPayload = NULL;
 268        *payload = NULL;
 269        *size = 0;
 270        ret = OC_STACK_ERROR;
 271     }
 272
 273     return ret;
 274 }
 275
 276 OCStackResult CBORPayloadToDpair(const uint8_t *cborPayload, size_t size,
 277                                 OicSecDpairing_t **secDpair)
 278 {
 279     if (NULL == cborPayload || NULL == secDpair || NULL != *secDpair || 0 == size)
 280     {
 281         return OC_STACK_INVALID_PARAM;
 282     }
 283
 284     OCStackResult ret = OC_STACK_ERROR;
 285     *secDpair = NULL;
 286
 287     CborValue dpairCbor = { .parser = NULL };
 288     CborParser parser = { .end = NULL };
 289     CborError cborFindResult = CborNoError;
 290
 291     cbor_parser_init(cborPayload, size, 0, &parser, &dpairCbor);
 292     CborValue dpairMap = { .parser = NULL };
 293     OicSecDpairing_t *dpair = NULL;
 294     cborFindResult = cbor_value_enter_container(&dpairCbor, &dpairMap);
 295     VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Entering DPairing Map");
 296
 297     dpair = (OicSecDpairing_t *)OICCalloc(1, sizeof(*dpair));
 298     VERIFY_NON_NULL(TAG, dpair, ERROR);
 299
 300     while (cbor_value_is_valid(&dpairMap))
 301     {
 302         char *name = NULL;
 303         size_t len = 0;
 304         CborType type = CborInvalidType;
 305         cborFindResult = cbor_value_dup_text_string(&dpairMap, &name, &len, NULL);
 306         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding tag name");
 307         cborFindResult = cbor_value_advance(&dpairMap);
 308         VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing a value in DPair map");
 309
 310         type = cbor_value_get_type(&dpairMap);
 311         if (0 == strcmp(OIC_JSON_SPM_NAME, name))
 312         {
 313             cborFindResult = cbor_value_get_int(&dpairMap, (int *) &dpair->spm);
 314             VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding SPM Value");
 315         }
 316
 317         if (0 == strcmp(OIC_JSON_PDEVICE_ID_NAME, name))
 318         {
 319             char *id = NULL;
 320             cborFindResult = cbor_value_dup_text_string(&dpairMap, &id, &len, NULL);
 321             VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding PDeviceID value");
 322             ret = ConvertStrToUuid(id, &dpair->pdeviceID);
 323             VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
 324             OICFree(id);
 325         }
 326
 327         if (0 == strcmp(OIC_JSON_ROWNERID_NAME, name))
 328         {
 329             char *id = NULL;
 330             cborFindResult = cbor_value_dup_text_string(&dpairMap, &id, &len, NULL);
 331             VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding RownerID value");
 332             ret = ConvertStrToUuid(id, &dpair->rownerID);
 333             VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
 334             OICFree(id);
 335         }
 336
 337         if (CborMapType != type && cbor_value_is_valid(&dpairMap))
 338         {
 339             cborFindResult = cbor_value_advance(&dpairMap);
 340             VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Advancing the Dpair Map");
 341         }
 342         OICFree(name);
 343     }
 344
 345     *secDpair = dpair;
 346     ret = OC_STACK_OK;
 347
 348 exit:
 349     if (CborNoError != cborFindResult)
 350     {
 351         OIC_LOG (ERROR, TAG, "CBORPayloadToDoxm failed");
 352         DeleteDpairingBinData(dpair);
 353         dpair = NULL;
 354         *secDpair = NULL;
 355         ret = OC_STACK_ERROR;
 356     }
 357     return ret;
 358 }
 359 /**
 360  * Function to handle the handshake result in Direct-Pairing.
 361  * This function will be invoked after DTLS handshake
 362  * @param   endPoint  [IN] The remote endpoint.
 363  * @param   errorInfo [IN] Error information from the endpoint.
 364  * @return  NONE
 365  */
 366 void DPairingDTLSHandshakeCB(const CAEndpoint_t *endpoint, const CAErrorInfo_t *info)
 367 {
 368     OIC_LOG_V(INFO, TAG, "IN DPairingDTLSHandshakeCB");
 369
 370     if(gDpair && endpoint && info)
 371     {
 372         OIC_LOG_V(INFO, TAG, "Received status from remote device(%s:%d) : %d",
 373                  endpoint->addr, endpoint->port, info->result);
 374
 375         if(CA_STATUS_OK == info->result)
 376         {
 377             OIC_LOG(INFO, TAG, "DPairingDTLSHandshakeCB - Connection success.");
 378         }
 379         else if(CA_DTLS_AUTHENTICATION_FAILURE == info->result)
 380         {
 381             OIC_LOG(INFO, TAG, "DPairingDTLSHandshakeCB - Authentication failed");
 382
 383         }
 384
 385 #ifdef __WITH_DTLS__
 386         CARegisterDTLSHandshakeCallback(NULL);
 387 #endif // __WITH_DTLS__
 388
 389         // delete temporary key
 390         RemoveCredential(&gDpair->pdeviceID);
 391     }
 392
 393     OIC_LOG_V(INFO, TAG, "OUT DPairingDTLSHandshakeCB");
 394 }
 395
 396 static OCEntityHandlerResult HandleDpairingPostRequest (const OCEntityHandlerRequest * ehRequest)
 397 {
 398     OIC_LOG (DEBUG, TAG, "Dpairing EntityHandle  processing POST request");
 399     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 400     OicSecDpairing_t* newDpair = NULL;
 401     OCStackResult res = OC_STACK_OK;
 402
 403     const OicSecPconf_t *pconf = GetPconfResourceData();
 404     if (true == pconf->edp)
 405     {
 406         uint8_t *payload = ((OCSecurityPayload*)ehRequest->payload)->securityData;
 407         size_t size = ((OCSecurityPayload*)ehRequest->payload)->payloadSize;
 408         if (payload)
 409         {
 410             res = CBORPayloadToDpair(payload, size, &newDpair);
 411         }
 412     }
 413     else
 414     {
 415         OIC_LOG (DEBUG, TAG, "EDP == false : Direct-Pairing Disabled");
 416         ehRet = OC_EH_ERROR;
 417     }
 418
 419     if (OC_STACK_OK == res && newDpair && false == IsPairedDevice(&newDpair->pdeviceID))
 420     {
 421         // Check if valid Post request
 422         bool prmMached = false;
 423         for (size_t i=0; i<pconf->prmLen; i++)
 424         {
 425             if (newDpair->spm == pconf->prm[i])
 426             {
 427                 prmMached = true;
 428                 break;
 429             }
 430         }
 431         OIC_LOG_V(DEBUG, TAG, "Parsed spm is %s", prmMached ? "valid" :
 432                 "invalid, send error response");
 433
 434         // Update local Dpairing with new Dpairing & prepare dtls session
 435         if (prmMached && '\0' != (char)newDpair->pdeviceID.id[0])
 436         {
 437             if(!gDpair)
 438             {
 439                 gDpair = GetDpairingDefault();
 440             }
 441             gDpair->spm = newDpair->spm;
 442             memcpy(&gDpair->pdeviceID, &newDpair->pdeviceID, sizeof(OicUuid_t));
 443             memcpy(&gDpair->rownerID, &pconf->rownerID, sizeof(OicUuid_t));
 444
 445 #ifdef __WITH_DTLS__
 446             // Add temporary psk
 447             OCStackResult res;
 448             OicUuid_t subjectId = {.id={0}};
 449             res = AddTmpPskWithPIN(&gDpair->pdeviceID,
 450                            SYMMETRIC_PAIR_WISE_KEY,
 451                            (char*)pconf->pin.val, DP_PIN_LENGTH,
 452                            &gDpair->rownerID, &subjectId);
 453             if(res != OC_STACK_OK ||
 454                     memcmp(&gDpair->pdeviceID, &subjectId, sizeof(OicUuid_t)))
 455             {
 456                 OIC_LOG_V(ERROR, TAG, "Failed to save the temporal PSK : %d", res);
 457                 goto exit;
 458             }
 459
 460             // Prepare to establish a secure channel with Pin-based PSK cipher suite
 461             if (CA_STATUS_OK != CAEnableAnonECDHCipherSuite(false) ||
 462                 CA_STATUS_OK != CASelectCipherSuite(TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA_256))
 463             {
 464                 OIC_LOG_V(ERROR, TAG, "Failed to select TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA_256");
 465                 goto exit;
 466             }
 467
 468             if(CA_STATUS_OK != CARegisterDTLSHandshakeCallback(DPairingDTLSHandshakeCB))
 469             {
 470                 OIC_LOG(WARNING, TAG, "DirectPairingHandler : Failed to register"
 471                         " DTLS handshake callback.");
 472                 goto exit;
 473             }
 474 #endif // __WITH_DTLS__
 475
 476             // should be lock /oic/sec/dpairing resource if Direct-Pairing starts normally ?
 477             OIC_LOG (DEBUG, TAG, "/oic/sec/dpairing resource created");
 478
 479             ehRet = OC_EH_RESOURCE_CREATED;
 480         }
 481         else
 482         {
 483             OIC_LOG(ERROR, TAG, "Error in request check");
 484         }
 485     }
 486
 487
 488 #ifdef __WITH_DTLS__
 489 exit:
 490 #endif // __WITH_DTLS__
 491
 492     // Send payload to request originator
 493     if(OC_STACK_OK != SendSRMResponse(ehRequest, ehRet, NULL, 0))
 494     {
 495         ehRet = OC_EH_ERROR;
 496         OIC_LOG (ERROR, TAG, "SendSRMResponse failed in HandleDpairingPostRequest");
 497     }
 498
 499     if (OC_EH_ERROR == ehRet && gDpair)
 500     {
 501         RemoveCredential(&gDpair->pdeviceID);
 502         gDpair = NULL;
 503     }
 504
 505     DeleteDpairingBinData(newDpair);
 506     OIC_LOG_V (DEBUG, TAG, "%s RetVal %d", __func__ , ehRet);
 507     return ehRet;
 508 }
 509
 510 static OCEntityHandlerResult HandleDpairingPutRequest (const OCEntityHandlerRequest * ehRequest)
 511 {
 512     OIC_LOG (DEBUG, TAG, "Dpairing EntityHandle  processing PUT request (Comfirmation)");
 513
 514     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 515     OicSecDpairing_t* newDpair = NULL;
 516     OCStackResult res = OC_STACK_OK;
 517
 518     const OicSecPconf_t *pconf = GetPconfResourceData();
 519     if (true == pconf->edp)
 520     {
 521         uint8_t *payload = ((OCSecurityPayload*)ehRequest->payload)->securityData;
 522         size_t size = ((OCSecurityPayload*)ehRequest->payload)->payloadSize;
 523         if (payload)
 524         {
 525             res = CBORPayloadToDpair(payload, size, &newDpair);
 526         }
 527
 528     }
 529     else
 530     {
 531         OIC_LOG (DEBUG, TAG, "EDP == false : Direct-Pairing Disabled");
 532         ehRet = OC_EH_ERROR;
 533     }
 534
 535
 536     if ((OC_STACK_OK == res) && gDpair && newDpair)
 537     {
 538         OIC_LOG(DEBUG, TAG, "Received direct-pairing finalization request");
 539
 540         // Check if valid Put request
 541         VERIFY_SUCCESS(TAG, PRM_NOT_ALLOWED == newDpair->spm, ERROR);
 542
 543         const OicSecPconf_t *pconf = GetPconfResourceData();
 544         VERIFY_NON_NULL(TAG, pconf, ERROR);
 545
 546 #ifdef __WITH_DTLS__
 547         OCServerRequest * request = (OCServerRequest *)ehRequest->requestHandle;
 548         VERIFY_SUCCESS(TAG, (request->devAddr.flags | OC_FLAG_SECURE), ERROR);
 549
 550         //Generate new credential
 551         OIC_LOG_V(INFO, TAG, "SavePairingPSK for %s(%d)", request->devAddr.addr,
 552                 request->devAddr.port);
 553         OCStackResult res = SavePairingPSK(&request->devAddr, &newDpair->pdeviceID,
 554                 (OicUuid_t *)&pconf->rownerID, true);
 555         VERIFY_SUCCESS(TAG, OC_STACK_OK == res, ERROR);
 556 #endif //__WITH_DTLS__
 557
 558         //Generate new acl
 559         OicSecPdAcl_t *pdAcl;
 560         LL_FOREACH(pconf->pdacls, pdAcl)
 561         {
 562             OicSecAcl_t acl;
 563             memset(&acl, 0, sizeof(OicSecAcl_t));
 564             memcpy(&acl.subject, &gDpair->pdeviceID, sizeof(OicUuid_t));
 565             acl.resources = pdAcl->resources;
 566             acl.resourcesLen = pdAcl->resourcesLen;
 567             memcpy(&acl.rownerID, &pconf->rownerID, sizeof(OicUuid_t));
 568             acl.permission = pdAcl->permission;
 569             acl.periods = pdAcl->periods;
 570             acl.recurrences = pdAcl->recurrences;
 571             acl.prdRecrLen = pdAcl->prdRecrLen;
 572
 573             size_t size = 0;
 574             uint8_t *payload = NULL;
 575             if (OC_STACK_OK == AclToCBORPayload(&acl, &payload, &size))
 576             {
 577                 InstallNewACL(payload, size);
 578                 OICFree(payload);
 579             }
 580         }
 581
 582         //update pconf device list
 583         AddPairedDevice(&newDpair->pdeviceID);
 584
 585         //Initialize dpairing resource
 586         gDpair = NULL;
 587
 588         OIC_LOG (DEBUG, TAG, "/oic/sec/dpairing resource updated,"
 589                 "direct-pairing finalization success");
 590         ehRet = OC_EH_OK;
 591     }
 592
 593 exit:
 594
 595     //Send payload to request originator
 596     if(OC_STACK_OK != SendSRMResponse(ehRequest, ehRet, NULL, 0))
 597     {
 598         ehRet = OC_EH_ERROR;
 599         OIC_LOG (ERROR, TAG, "SendSRMResponse failed in HandleDpairingPutRequest");
 600     }
 601
 602     DeleteDpairingBinData(newDpair);
 603     OIC_LOG_V (DEBUG, TAG, "%s RetVal %d", __func__ , ehRet);
 604     return ehRet;
 605 }
 606 /*
 607  * This internal method is the entity handler for Dpairing resources and
 608  * will handle REST request (GET/POST) for them.
 609  */
 610 OCEntityHandlerResult DpairingEntityHandler (OCEntityHandlerFlag flag,
 611                                         OCEntityHandlerRequest * ehRequest,
 612                                         void* callbackParameter)
 613 {
 614     OIC_LOG(DEBUG, TAG, "Received request DpairingEntityHandler");
 615     (void)callbackParameter;
 616     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 617
 618     if (!ehRequest)
 619     {
 620         return ehRet;
 621     }
 622
 623     if (flag & OC_REQUEST_FLAG)
 624     {
 625         OIC_LOG (DEBUG, TAG, "Flag includes OC_REQUEST_FLAG");
 626         switch (ehRequest->method)
 627         {
 628             case OC_REST_GET:
 629                 break;
 630
 631             case OC_REST_POST:
 632                 ehRet = HandleDpairingPostRequest(ehRequest);
 633                 break;
 634
 635             case OC_REST_PUT:
 636                 ehRet = HandleDpairingPutRequest(ehRequest);
 637                 break;
 638
 639             case OC_REST_DELETE:
 640                 break;
 641
 642             default:
 643                 ehRet = OC_EH_ERROR;
 644                 SendSRMResponse(ehRequest, ehRet, NULL, 0);
 645         }
 646     }
 647
 648     return ehRet;
 649 }
 650
 651 /*
 652  * This internal method is used to create '/oic/sec/dpairing' resource.
 653  */
 654 OCStackResult CreateDpairingResource()
 655 {
 656     OCStackResult ret;
 657
 658     ret = OCCreateResource(&gDpairHandle,
 659                            OIC_RSRC_TYPE_SEC_DPAIRING,
 660                            OIC_MI_DEF,
 661                            OIC_RSRC_DPAIRING_URI,
 662                            DpairingEntityHandler,
 663                            NULL,
 664                            OC_SECURE | OC_EXPLICIT_DISCOVERABLE);
 665
 666     if (OC_STACK_OK != ret)
 667     {
 668         OIC_LOG (ERROR, TAG, "Unable to instantiate Dpairing resource");
 669         DeInitDpairingResource();
 670     }
 671     return ret;
 672 }
 673
 674 /**
 675  * Initialize Dpairing resource by loading data from persistent storage.
 676  *
 677  * @retval  OC_STACK_OK for Success, otherwise some error value
 678  */
 679 OCStackResult InitDpairingResource()
 680 {
 681     OCStackResult ret = OC_STACK_ERROR;
 682
 683     // Instantiate 'oic.sec.dpairing'
 684     ret = CreateDpairingResource();
 685     if (OC_STACK_OK != ret)
 686     {
 687         DeInitDpairingResource();
 688     }
 689     return ret;
 690 }
 691
 692 /**
 693  * Perform cleanup for Dpairing resources.
 694  *
 695  * @return
 696  * OC_STACK_OK    - no error
 697  * OC_STACK_ERROR - stack process error
 698  *
 699  */
 700 OCStackResult DeInitDpairingResource()
 701 {
 702     OCStackResult ret = OCDeleteResource(gDpairHandle);
 703     gDpair = NULL;
 704
 705     if(OC_STACK_OK == ret)
 706     {
 707         return OC_STACK_OK;
 708     }
 709     else
 710     {
 711         return OC_STACK_ERROR;
 712     }
 713 }
 714
 715 OCStackResult SetDpairingRownerId(const OicUuid_t* newROwner)
 716 {
 717     OCStackResult ret = OC_STACK_ERROR;
 718     uint8_t *cborPayload = NULL;
 719     size_t size = 0;
 720     OicUuid_t prevId = {.id={0}};
 721
 722     if(NULL == newROwner)
 723     {
 724         ret = OC_STACK_INVALID_PARAM;
 725     }
 726     if(NULL == gDpair)
 727     {
 728         ret = OC_STACK_NO_RESOURCE;
 729     }
 730
 731     if(newROwner && gDpair)
 732     {
 733         memcpy(prevId.id, gDpair->rownerID.id, sizeof(prevId.id));
 734         memcpy(gDpair->rownerID.id, newROwner->id, sizeof(newROwner->id));
 735
 736         ret = DpairingToCBORPayload(gDpair, &cborPayload, &size);
 737         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 738
 739         ret = UpdateSecureResourceInPS(OIC_JSON_DPAIRING_NAME, cborPayload, size);
 740         VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
 741
 742         OICFree(cborPayload);
 743     }
 744
 745     return ret;
 746
 747 exit:
 748     OICFree(cborPayload);
 749     memcpy(gDpair->rownerID.id, prevId.id, sizeof(prevId.id));
 750     return ret;
 751 }
 752
 753 OCStackResult GetDpairingRownerId(OicUuid_t *rowneruuid)
 754 {
 755     OCStackResult retVal = OC_STACK_ERROR;
 756     if (gDpair)
 757     {
 758         *rowneruuid = gDpair->rownerID;
 759         retVal = OC_STACK_OK;
 760     }
 761     return retVal;
 762 }