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