ffd1256d27dd13a80adab29ad305bf784d8039a2
[platform/upstream/iotivity.git] / resource / csdk / security / provisioning / src / ocprovisioningmanager.c
1 /* *****************************************************************
2  *
3  * Copyright 2015 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 #include <stdint.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include "ocprovisioningmanager.h"
24 #include "pmutility.h"
25 #include "srmutility.h"
26 #include "ownershiptransfermanager.h"
27 #ifdef MULTIPLE_OWNER
28 #include "multipleownershiptransfermanager.h"
29 #endif //MULTIPLE_OWNER
30 #include "oic_malloc.h"
31 #include "logger.h"
32 #include "secureresourceprovider.h"
33 #include "provisioningdatabasemanager.h"
34 #include "credresource.h"
35 #include "utlist.h"
36 #include "aclresource.h" //Note: SRM internal header
37 #include "pconfresource.h"
38 #include "psinterface.h"
39 #include "srmresourcestrings.h"
40
41 #define TAG "OIC_OCPMAPI"
42
43 typedef struct Linkdata Linkdata_t;
44 struct Linkdata
45 {
46     void *ctx;
47     const OCProvisionDev_t *pDev1;
48     OicSecAcl_t *pDev1Acl;
49     const OCProvisionDev_t *pDev2;
50     OicSecAcl_t *pDev2Acl;
51     OCProvisionResult_t *resArr;
52     int numOfResults;
53     int currentCountResults;
54     OCProvisionResultCB resultCallback;
55
56 };
57
58 #ifdef MULTIPLE_OWNER
59 typedef struct ProvPreconfPINCtx ProvPreconfPINCtx_t;
60 struct ProvPreconfPINCtx
61 {
62     void *ctx;
63     const OCProvisionDev_t *devInfo;
64     const char* pin;
65     size_t pinLen;
66     OCProvisionResultCB resultCallback;
67 };
68 #endif //MULTIPLE_OWNER
69
70 /**
71  * The function is responsible for initializaton of the provisioning manager. It will load
72  * provisioning database which have owned device's list and their linked status.
73  * TODO: In addition, if there is a device(s) which has not up-to-date credentials, this function will
74  * automatically try to update the deivce(s).
75  *
76  * @param[in] dbPath file path of the sqlite3 db
77  *
78  * @return OC_STACK_OK in case of success and other value otherwise.
79  */
80 OCStackResult OCInitPM(const char* dbPath)
81 {
82     return PDMInit(dbPath);
83 }
84
85 void OCTerminatePM()
86 {
87     OTMTerminate();
88 }
89
90 OCStackResult OCPDMCleanupForTimeout()
91 {
92     return PDMDeleteDeviceWithState(PDM_DEVICE_INIT);
93 }
94
95 /**
96  * The function is responsible for discovery of owned/unowned device is specified endpoint/deviceID.
97  * And this function will only return the specified device's response.
98  *
99  * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
100  *                    server before returning the device.
101  * @param[in] deviceID         deviceID of target device.
102  * @param[out] ppFoundDevice     OCProvisionDev_t of found device
103  * @return OTM_SUCCESS in case of success and other value otherwise.
104  */
105 OCStackResult OCDiscoverSingleDevice(unsigned short timeout, const OicUuid_t* deviceID,
106                              OCProvisionDev_t **ppFoundDevice)
107 {
108     if( NULL == ppFoundDevice || NULL != *ppFoundDevice || 0 == timeout || NULL == deviceID)
109     {
110         return OC_STACK_INVALID_PARAM;
111     }
112
113     return PMSingleDeviceDiscovery(timeout, deviceID, ppFoundDevice);
114 }
115
116 /**
117  * The function is responsible for discovery of owned/unowned device is specified endpoint/deviceID.
118  * And this function will only return the specified device's response.
119  *
120  * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
121  *                    server before returning the device.
122  * @param[in] deviceID         deviceID of target device.
123  * @param[in] hostAddress       MAC address of target device.
124  * @param[in] connType       ConnectivityType for discovery.
125  * @param[out] ppFoundDevice     OCProvisionDev_t of found device.
126  * @return OTM_SUCCESS in case of success and other value otherwise.
127  */
128 OCStackResult OCDiscoverSingleDeviceInUnicast(unsigned short timeout, const OicUuid_t* deviceID,
129                              const char* hostAddress, OCConnectivityType connType,
130                              OCProvisionDev_t **ppFoundDevice)
131 {
132     if( NULL == ppFoundDevice || NULL != *ppFoundDevice || 0 == timeout || NULL == deviceID ||
133             NULL == hostAddress)
134     {
135         OIC_LOG(ERROR, TAG, "OCDiscoverSingleDeviceInUnicast : Invalid Parameter");
136         return OC_STACK_INVALID_PARAM;
137     }
138
139     return PMSingleDeviceDiscoveryInUnicast(timeout, deviceID, hostAddress, connType,
140             ppFoundDevice);
141 }
142
143 /**
144  * The function is responsible for discovery of device is current subnet. It will list
145  * all the device in subnet which are not yet owned. Please call OCInit with OC_CLIENT_SERVER as
146  * OCMode.
147  *
148  * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
149  *                    server before returning the list of devices.
150  * @param[out] ppList List of candidate devices to be provisioned
151  * @return OTM_SUCCESS in case of success and other value otherwise.
152  */
153 OCStackResult OCDiscoverUnownedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
154 {
155     if( ppList == NULL || *ppList != NULL || 0 == timeout)
156     {
157         return OC_STACK_INVALID_PARAM;
158     }
159
160     return PMDeviceDiscovery(timeout, false, ppList);
161 }
162
163 /**
164  * The function is responsible for discovery of owned device is current subnet. It will list
165  * all the device in subnet which are owned by calling provisioning client.
166  *
167  * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
168  *                    server before returning the list of devices.
169  * @param[out] ppList List of device owned by provisioning tool.
170  * @return OTM_SUCCESS in case of success and other value otherwise.
171  */
172 OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
173 {
174     if( ppList == NULL || *ppList != NULL || 0 == timeout)
175     {
176         return OC_STACK_INVALID_PARAM;
177     }
178
179     return PMDeviceDiscovery(timeout, true, ppList);
180 }
181
182 #ifdef MULTIPLE_OWNER
183 /**
184  * The function is responsible for discovery of MOT enabled device is current subnet.
185  *
186  * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
187  *                    server before returning the list of devices.
188  * @param[out] ppList List of MOT enabled devices.
189  * @return OC_STACK_OK in case of success and other value otherwise.
190  */
191 OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
192 {
193     if( ppList == NULL || *ppList != NULL || 0 == timeout)
194     {
195         return OC_STACK_INVALID_PARAM;
196     }
197
198     return PMMultipleOwnerDeviceDiscovery(timeout, false, ppList);
199 }
200
201 /**
202  * The function is responsible for discovery of Multiple Owned device is current subnet.
203  *
204  * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
205  *                    server before returning the list of devices.
206  * @param[out] ppList List of Multiple Owned devices.
207  * @return OC_STACK_OK in case of success and other value otherwise.
208  */
209 OCStackResult OCDiscoverMultipleOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
210 {
211     if( ppList == NULL || *ppList != NULL || 0 == timeout)
212     {
213         return OC_STACK_INVALID_PARAM;
214     }
215
216     return PMMultipleOwnerDeviceDiscovery(timeout, true, ppList);
217 }
218
219
220 /**
221  * API to add preconfigured PIN to local SVR DB.
222  *
223  * @param[in] targetDeviceInfo Selected target device.
224  * @param[in] preconfigPin Preconfig PIN which is used while multiple owner authentication
225  * @param[in] preconfigPinLen Byte length of preconfigPin
226  *
227  * @return OC_STACK_OK in case of success and other value otherwise.
228  */
229 OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo,
230                                 const char *preconfigPin,
231                                 size_t preconfigPinLen)
232 {
233     return MOTAddPreconfigPIN(targetDeviceInfo, preconfigPin, preconfigPinLen);
234 }
235
236
237 OCStackResult OCDoMultipleOwnershipTransfer(void* ctx,
238                                       OCProvisionDev_t *targetDevices,
239                                       OCProvisionResultCB resultCallback)
240 {
241     if( NULL == targetDevices )
242     {
243         return OC_STACK_INVALID_PARAM;
244     }
245     if (NULL == resultCallback)
246     {
247         OIC_LOG(INFO, TAG, "OCDoOwnershipTransfer : NULL Callback");
248         return OC_STACK_INVALID_CALLBACK;
249     }
250     return MOTDoOwnershipTransfer(ctx, targetDevices, resultCallback);
251 }
252
253 OCStackResult OCRemoveSubOwner(void* ctx,
254                                 const OCProvisionDev_t *targetDeviceInfo,
255                                 const OicUuid_t* subOwner,
256                                 OCProvisionResultCB resultCallback)
257 {
258     if (NULL == targetDeviceInfo || NULL == subOwner)
259     {
260         OIC_LOG_V(ERROR, TAG, "%s : NULL Param", __func__);
261         return OC_STACK_INVALID_PARAM;
262     }
263     if (NULL == resultCallback)
264     {
265         OIC_LOG_V(ERROR, TAG, "%s : NULL Callback", __func__);
266         return OC_STACK_INVALID_CALLBACK;
267     }
268
269     return MOTRemoveSubOwner(ctx, targetDeviceInfo, subOwner, resultCallback);
270 }
271
272 OCStackResult OCRemoveAllSubOwner(void* ctx,
273                                 const OCProvisionDev_t *targetDeviceInfo,
274                                 OCProvisionResultCB resultCallback)
275 {
276     if (NULL == targetDeviceInfo)
277     {
278         OIC_LOG_V(ERROR, TAG, "%s : NULL Param", __func__);
279         return OC_STACK_INVALID_PARAM;
280     }
281     if (NULL == resultCallback)
282     {
283         OIC_LOG_V(ERROR, TAG, "%s : NULL Callback", __func__);
284         return OC_STACK_INVALID_CALLBACK;
285     }
286
287     return MOTRemoveSubOwner(ctx, targetDeviceInfo, &WILDCARD_SUBJECT_ID, resultCallback);
288 }
289
290
291 #endif //MULTIPLE_OWNER
292
293 /**
294  * API to register for particular OxM.
295  *
296  * @param[in] Ownership transfer method.
297  * @param[in] Implementation of callback functions for owership transfer.
298  * @return  OC_STACK_OK in case of success and other value otherwise.
299  */
300 OCStackResult OCSetOwnerTransferCallbackData(OicSecOxm_t oxm, OTMCallbackData_t* callbackData)
301 {
302     if(NULL == callbackData)
303     {
304         return OC_STACK_INVALID_CALLBACK ;
305     }
306
307     return OTMSetOwnershipTransferCallbackData(oxm, callbackData);
308 }
309
310 /**
311  * API to set a allow status of OxM
312  *
313  * @param[in] oxm Owership transfer method (ref. OicSecOxm_t)
314  * @param[in] allowStatus allow status (true = allow, false = not allow)
315  *
316  * @return OC_STACK_OK in case of success and other value otherwise.
317  */
318 OCStackResult OCSetOxmAllowStatus(const OicSecOxm_t oxm, const bool allowStatus)
319 {
320     return OTMSetOxmAllowStatus(oxm, allowStatus);
321 }
322
323 OCStackResult OCDoOwnershipTransfer(void* ctx,
324                                       OCProvisionDev_t *targetDevices,
325                                       OCProvisionResultCB resultCallback)
326 {
327     if( NULL == targetDevices )
328     {
329         return OC_STACK_INVALID_PARAM;
330     }
331     if (!resultCallback)
332     {
333         OIC_LOG(INFO, TAG, "OCDoOwnershipTransfer : NULL Callback");
334         return OC_STACK_INVALID_CALLBACK;
335     }
336     return OTMDoOwnershipTransfer(ctx, targetDevices, resultCallback);
337 }
338
339 /**
340  * This function deletes memory allocated to linked list created by OCDiscover_XXX_Devices API.
341  *
342  * @param[in] pList Pointer to OCProvisionDev_t which should be deleted.
343  */
344 void OCDeleteDiscoveredDevices(OCProvisionDev_t *pList)
345 {
346     PMDeleteDeviceList(pList);
347 }
348
349 /**
350  * this function sends ACL information to resource.
351  *
352  * @param[in] ctx Application context would be returned in result callback.
353  * @param[in] selectedDeviceInfo Selected target device.
354  * @param[in] acl ACL to provision.
355  * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
356               request recieves a response from resource server.
357  * @return  OC_STACK_OK in case of success and other value otherwise.
358  */
359 OCStackResult OCProvisionACL(void* ctx, const OCProvisionDev_t *selectedDeviceInfo, OicSecAcl_t *acl,
360                              OCProvisionResultCB resultCallback)
361 {
362     return SRPProvisionACL(ctx, selectedDeviceInfo, acl, resultCallback);
363 }
364
365 /**
366  * function to save ACL which has several ACE into Acl of SVR.
367  *
368  * @param acl ACL to be saved in Acl of SVR.
369  * @return  OC_STACK_OK in case of success and other value otherwise.
370  */
371 OCStackResult OCSaveACL(const OicSecAcl_t* acl)
372 {
373     return SRPSaveACL(acl);
374 }
375
376 /**
377  * this function requests CRED information to resource.
378  *
379  * @param[in] ctx Application context would be returned in result callback.
380  * @param[in] selectedDeviceInfo Selected target device.
381  * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
382               request recieves a response from resource server.
383  * @return  OC_STACK_OK in case of success and other value otherwise.
384  */
385 OCStackResult OCGetCredResource(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
386                              OCProvisionResultCB resultCallback)
387 {
388     return SRPGetCredResource(ctx, selectedDeviceInfo, resultCallback);
389 }
390
391 /**
392  * this function requests ACL information to resource.
393  *
394  * @param[in] ctx Application context would be returned in result callback.
395  * @param[in] selectedDeviceInfo Selected target device.
396  * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
397               request recieves a response from resource server.
398  * @return  OC_STACK_OK in case of success and other value otherwise.
399  */
400 OCStackResult OCGetACLResource(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
401                              OCProvisionResultCB resultCallback)
402 {
403     return SRPGetACLResource(ctx, selectedDeviceInfo, resultCallback);
404 }
405
406
407 OCStackResult OCReadTrustCertChain(uint16_t credId, uint8_t **trustCertChain,
408                                      size_t *chainSize)
409 {
410     return SRPReadTrustCertChain(credId, trustCertChain, chainSize);
411 }
412 /**
413  * function to provision credential to devices.
414  *
415  * @param[in] ctx Application context would be returned in result callback.
416  * @param[in] type Type of credentials to be provisioned to the device.
417  * @param[in] pDev1 Pointer to OCProvisionDev_t instance,respresenting resource to be provsioned.
418    @param[in] pDev2 Pointer to OCProvisionDev_t instance,respresenting resource to be provsioned.
419  * @param[in] resultCallback callback provided by API user, callback will be called when
420  *            provisioning request recieves a response from first resource server.
421  * @return  OC_STACK_OK in case of success and other value otherwise.
422  */
423 OCStackResult OCProvisionCredentials(void *ctx, OicSecCredType_t type, size_t keySize,
424                                       const OCProvisionDev_t *pDev1,
425                                       const OCProvisionDev_t *pDev2,
426                                       OCProvisionResultCB resultCallback)
427 {
428     return SRPProvisionCredentials(ctx, type, keySize,
429                                       pDev1, pDev2, resultCallback);
430
431 }
432
433 /**
434  * this function sends Direct-Pairing Configuration to a device.
435  *
436  * @param[in] ctx Application context would be returned in result callback.
437  * @param[in] selectedDeviceInfo Selected target device.
438  * @param[in] pconf PCONF pointer.
439  * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
440               request recieves a response from resource server.
441  * @return  OC_STACK_OK in case of success and other value otherwise.
442  */
443 OCStackResult OCProvisionDirectPairing(void* ctx, const OCProvisionDev_t *selectedDeviceInfo, OicSecPconf_t *pconf,
444                              OCProvisionResultCB resultCallback)
445 {
446     return SRPProvisionDirectPairing(ctx, selectedDeviceInfo, pconf, resultCallback);
447 }
448
449 #ifdef MULTIPLE_OWNER
450 static void AddPreconfPinOxMCB(void* ctx, int nOfRes, OCProvisionResult_t *arr, bool hasError)
451 {
452     ProvPreconfPINCtx_t* provCtx = (ProvPreconfPINCtx_t*)ctx;
453     if(provCtx)
454     {
455         OCStackResult res = MOTProvisionPreconfigPIN(provCtx->ctx, provCtx->devInfo, provCtx->pin, provCtx->pinLen, provCtx->resultCallback);
456         if(OC_STACK_OK != res)
457         {
458             arr->res = res;
459             provCtx->resultCallback(provCtx->ctx, nOfRes, arr, true);
460         }
461     }
462 }
463
464 OCStackResult OCProvisionPreconfigPin(void *ctx,
465                                       OCProvisionDev_t *targetDeviceInfo,
466                                       const char *preconfigPin,
467                                       size_t preconfigPinLen,
468                                       OCProvisionResultCB resultCallback)
469 {
470     if( NULL == targetDeviceInfo || NULL == preconfigPin || 0 == preconfigPinLen )
471     {
472         return OC_STACK_INVALID_PARAM;
473     }
474     if (NULL == resultCallback)
475     {
476         OIC_LOG(INFO, TAG, "OCProvisionPreconfigPinCredential : NULL Callback");
477         return OC_STACK_INVALID_CALLBACK;
478     }
479
480     ProvPreconfPINCtx_t* provCtx = (ProvPreconfPINCtx_t*)OICCalloc(1, sizeof(ProvPreconfPINCtx_t));
481     if(NULL == provCtx)
482     {
483         return OC_STACK_NO_MEMORY;
484     }
485     provCtx->ctx = ctx;
486     provCtx->devInfo = targetDeviceInfo;
487     provCtx->pin = preconfigPin;
488     provCtx->pinLen = preconfigPinLen;
489     provCtx->resultCallback = resultCallback;
490     /*
491      * First of all, update OxMs to support preconfigured PIN OxM.
492      * In case of Preconfigured PIN OxM already supported on the server side,
493      * MOTAddMOTMethod API will be send POST Cred request.
494      * In case of Preconfigure PIN OxM not exist on the server side,
495      * the MOTAddMOTMethod API will be send POST doxm request to update OxMs and then send POST Cred request.
496      */
497     return MOTAddMOTMethod((void*)provCtx, targetDeviceInfo, OIC_PRECONFIG_PIN, AddPreconfPinOxMCB);
498 }
499 #endif //MULTIPLE_OWNER
500
501 /*
502 * Function to unlink devices.
503 * This function will remove the credential & relationship between the two devices.
504 *
505 * @param[in] ctx Application context would be returned in result callback
506 * @param[in] pTargetDev1 first device information to be unlinked.
507 * @param[in] pTargetDev2 second device information to be unlinked.
508 * @param[in] resultCallback callback provided by API user, callback will be called when
509 *            device unlink is finished.
510  * @return  OC_STACK_OK in case of success and other value otherwise.
511 */
512 OCStackResult OCUnlinkDevices(void* ctx,
513                               const OCProvisionDev_t* pTargetDev1,
514                               const OCProvisionDev_t* pTargetDev2,
515                               OCProvisionResultCB resultCallback)
516 {
517     OIC_LOG(INFO, TAG, "IN OCUnlinkDevices");
518     OCUuidList_t* idList = NULL;
519     size_t numOfDev = 0;
520
521     if (!pTargetDev1 || !pTargetDev2 || !pTargetDev1->doxm || !pTargetDev2->doxm)
522     {
523         OIC_LOG(ERROR, TAG, "OCUnlinkDevices : NULL parameters");
524         return OC_STACK_INVALID_PARAM;
525     }
526     if (!resultCallback)
527     {
528         OIC_LOG(INFO, TAG, "OCUnlinkDevices : NULL Callback");
529         return OC_STACK_INVALID_CALLBACK;
530     }
531     if (0 == memcmp(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID, sizeof(OicUuid_t)))
532     {
533         OIC_LOG(INFO, TAG, "OCUnlinkDevices : Same device ID");
534         return OC_STACK_INVALID_PARAM;
535     }
536
537     // Get linked devices with the first device.
538     OCStackResult res = PDMGetLinkedDevices(&(pTargetDev1->doxm->deviceID), &idList, &numOfDev);
539     if (OC_STACK_OK != res)
540     {
541         OIC_LOG(ERROR, TAG, "OCUnlinkDevices : PDMgetOwnedDevices failed");
542         goto error;
543     }
544     if (1 > numOfDev)
545     {
546         OIC_LOG(DEBUG, TAG, "OCUnlinkDevices : Can not find linked devices");
547         res = OC_STACK_INVALID_PARAM; // Input devices are not linked, No request is made
548         goto error;
549     }
550
551     // Check the linked devices contains the second device. If yes send credential DELETE request.
552     OCUuidList_t* curDev = idList;
553     while (NULL != curDev)
554     {
555         if (memcmp(pTargetDev2->doxm->deviceID.id, curDev->dev.id, sizeof(curDev->dev.id)) == 0)
556         {
557             res = SRPUnlinkDevices(ctx, pTargetDev1, pTargetDev2, resultCallback);
558             if (OC_STACK_OK != res)
559             {
560                 OIC_LOG(ERROR, TAG, "OCUnlinkDevices : Failed to unlink devices.");
561             }
562             goto error;
563         }
564         curDev = curDev->next;
565     }
566     OIC_LOG(DEBUG, TAG, "No matched pair found from provisioning database");
567     res = OC_STACK_INVALID_PARAM; // Input devices are not linked, No request is made
568
569 error:
570     OIC_LOG(INFO, TAG, "OUT OCUnlinkDevices");
571
572     PDMDestoryOicUuidLinkList(idList);
573     return res;
574 }
575
576 static OCStackResult RemoveDeviceInfoFromLocal(const OCProvisionDev_t* pTargetDev)
577 {
578     // Remove credential of revoked device from SVR database
579     OCStackResult res = OC_STACK_ERROR;
580     const OicSecCred_t *cred = NULL;
581
582     OIC_LOG(DEBUG, TAG, "IN RemoveDeviceInfoFromLocal");
583     cred = GetCredResourceData(&pTargetDev->doxm->deviceID);
584     if (NULL != cred)
585     {
586         res = RemoveCredential(&cred->subject);
587         if (res != OC_STACK_RESOURCE_DELETED)
588         {
589             OIC_LOG(ERROR, TAG, "RemoveDeviceInfoFromLocal : Failed to remove credential.");
590             goto error;
591         }
592     }
593     /**
594      * Change the device status as stale status.
595      * If all request are successed, this device information will be deleted.
596      */
597     res = PDMSetDeviceState(&pTargetDev->doxm->deviceID, PDM_DEVICE_STALE);
598     if (res != OC_STACK_OK)
599     {
600         OIC_LOG(WARNING, TAG, "OCRemoveDevice : Failed to set device status as stale");
601     }
602
603     // TODO: We need to add new mechanism to clean up the stale state of the device.
604
605     // Close the DTLS session of the removed device.
606     CAResult_t caResult = CAcloseSslConnectionUsingUuid(pTargetDev->doxm->deviceID.id
607                                                         , sizeof(pTargetDev->doxm->deviceID.id));
608     if(CA_STATUS_OK != caResult)
609     {
610         OIC_LOG_V(WARNING, TAG, "OCRemoveDevice : Failed to close (D)TLS session : %d", caResult);
611     }
612     OIC_LOG(DEBUG, TAG, "OUT RemoveDeviceInfoFromLocal");
613 error:
614     return res;
615 }
616
617 /*
618 * Function to device revocation
619 * This function will remove credential of target device from all devices in subnet.
620 *
621 * @param[in] ctx Application context would be returned in result callback
622 * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
623 * @param[in] pTargetDev Device information to be revoked.
624 * @param[in] resultCallback callback provided by API user, callback will be called when
625 *            credential revocation is finished.
626  * @return  OC_STACK_OK in case of success and other value otherwise.
627 */
628 OCStackResult OCRemoveDevice(void* ctx, unsigned short waitTimeForOwnedDeviceDiscovery,
629                             const OCProvisionDev_t* pTargetDev,
630                             OCProvisionResultCB resultCallback)
631 {
632     OIC_LOG(INFO, TAG, "IN OCRemoveDevice");
633     OCStackResult res = OC_STACK_ERROR;
634     if (!pTargetDev || 0 == waitTimeForOwnedDeviceDiscovery)
635     {
636         OIC_LOG(INFO, TAG, "OCRemoveDevice : Invalied parameters");
637         return OC_STACK_INVALID_PARAM;
638     }
639     if (!resultCallback)
640     {
641         OIC_LOG(INFO, TAG, "OCRemoveDevice : NULL Callback");
642         return OC_STACK_INVALID_CALLBACK;
643     }
644
645     // Send DELETE requests to linked devices
646     OCStackResult resReq = OC_STACK_ERROR; // Check that we have to wait callback or not.
647     resReq = SRPRemoveDevice(ctx, waitTimeForOwnedDeviceDiscovery, pTargetDev, resultCallback);
648     if (OC_STACK_OK != resReq)
649     {
650         if (OC_STACK_CONTINUE == resReq)
651         {
652             OIC_LOG(DEBUG, TAG, "OCRemoveDevice : Revoked device has no linked device except PT.");
653         }
654         else
655         {
656             OIC_LOG(ERROR, TAG, "OCRemoveDevice : Failed to invoke SRPRemoveDevice");
657             res = resReq;
658             goto error;
659         }
660     }
661
662     res = RemoveDeviceInfoFromLocal(pTargetDev);
663     if(OC_STACK_OK != res)
664     {
665         OIC_LOG(ERROR, TAG, "Filed to remove the device information from local.");
666         goto error;
667     }
668
669     if(OC_STACK_CONTINUE == resReq)
670     {
671         /**
672           * If there is no linked device, PM does not send any request.
673           * So we should directly invoke the result callback to inform the result of OCRemoveDevice.
674           */
675         if(resultCallback)
676         {
677             resultCallback(ctx, 0, NULL, false);
678         }
679         res = OC_STACK_OK;
680     }
681
682 error:
683     OIC_LOG(INFO, TAG, "OUT OCRemoveDevice");
684     return res;
685 }
686
687 /*
688 * Function to device revocation
689 * This function will remove credential of target device from all devices in subnet.
690 *
691 * @param[in] ctx Application context would be returned in result callback
692 * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
693 * @param[in] pTargetDev Device information to be revoked.
694 * @param[in] resultCallback callback provided by API user, callback will be called when
695 *            credential revocation is finished.
696  * @return  OC_STACK_OK in case of success and other value otherwise.
697 */
698 OCStackResult OCRemoveDeviceWithUuid(void* ctx, unsigned short waitTimeForOwnedDeviceDiscovery,
699                             const OicUuid_t* pTargetUuid,
700                             OCProvisionResultCB resultCallback)
701 {
702     OIC_LOG(INFO, TAG, "IN OCRemoveDeviceWithUuid");
703
704     OCStackResult res = OC_STACK_ERROR;
705     OCProvisionDev_t* pTargetDev = NULL;
706     bool discoverdFlag = false;
707     OCProvisionDev_t* pOwnedDevList = NULL;
708     OCStackResult resReq = OC_STACK_CONTINUE;
709
710     if (!pTargetUuid || 0 == waitTimeForOwnedDeviceDiscovery)
711     {
712         OIC_LOG(INFO, TAG, "OCRemoveDeviceWithUuid : Invalied parameters");
713         return OC_STACK_INVALID_PARAM;
714     }
715     if (!resultCallback)
716     {
717         OIC_LOG(INFO, TAG, "OCRemoveDeviceWithUuid : NULL Callback");
718         return OC_STACK_INVALID_CALLBACK;
719     }
720
721     char* strUuid = NULL;
722     if(OC_STACK_OK != ConvertUuidToStr(pTargetUuid, &strUuid))
723     {
724         OIC_LOG(WARNING, TAG, "Failed to covert UUID to String.");
725         goto error;
726     }
727
728     //Generate OCProvisionDev_t instance to use when target device not found on the network.
729     //In this case, the device id required only.
730     pTargetDev = (OCProvisionDev_t*)OICCalloc(1, sizeof(OCProvisionDev_t));
731     if(NULL == pTargetDev)
732     {
733         OIC_LOG(ERROR, TAG, "Failed to allocate memory.");
734         res = OC_STACK_NO_MEMORY;
735         goto error;
736     }
737     pTargetDev->doxm = (OicSecDoxm_t*)OICCalloc(1, sizeof(OicSecDoxm_t));
738     if(NULL == pTargetDev->doxm)
739     {
740         OIC_LOG(ERROR, TAG, "Failed to allocate memory.");
741         res = OC_STACK_NO_MEMORY;
742         goto error;
743     }
744     memcpy(pTargetDev->doxm->deviceID.id, pTargetUuid->id, sizeof(pTargetUuid->id));
745
746     OCUuidList_t* linkedDevices = NULL;
747     size_t numOfLinkedDevices = 0;
748     res = PDMGetLinkedDevices(pTargetUuid, &linkedDevices, &numOfLinkedDevices);
749     if(OC_STACK_OK != res)
750     {
751         OIC_LOG(ERROR, TAG, "Error in PDMGetLinkedDevices");
752         goto error;
753     }
754     PDMDestoryOicUuidLinkList(linkedDevices);
755
756     //If there is no linked devices, device revocation step can be skipped.
757     if(0 != numOfLinkedDevices)
758     {
759         OIC_LOG_V(INFO, TAG, "[%s] linked with other devices.", strUuid);
760         //2. Find owned device from the network
761         res = PMDeviceDiscovery(waitTimeForOwnedDeviceDiscovery, true, &pOwnedDevList);
762         if (OC_STACK_OK != res)
763         {
764             OIC_LOG(ERROR, TAG, "OCRemoveDeviceWithUuid : Failed to PMDeviceDiscovery");
765             goto error;
766         }
767
768         OCProvisionDev_t* tempDev = NULL;
769         LL_FOREACH(pOwnedDevList, tempDev)
770         {
771             if(memcmp(&tempDev->doxm->deviceID.id, pTargetUuid->id, sizeof(pTargetUuid->id)) == 0)
772             {
773                 break;
774             }
775         }
776
777         if(NULL == tempDev)
778         {
779             OIC_LOG_V(WARNING, TAG, "Can not find [%s] on the network.", strUuid);
780             OIC_LOG_V(WARNING, TAG, "[%s]'s information will be deleted from local and other devices.", strUuid);
781         }
782         else
783         {
784             OICFree(pTargetDev->doxm);
785             OICFree(pTargetDev);
786             pTargetDev = tempDev;
787             discoverdFlag = true;
788             OIC_LOG_V(INFO, TAG, "[%s] is dectected on the network.", strUuid);
789         }
790
791         OIC_LOG_V(INFO, TAG, "Trying [%s] revocation.", strUuid);
792
793         // Send DELETE requests to linked devices
794         resReq = SRPRemoveDeviceWithoutDiscovery(ctx, pOwnedDevList, pTargetDev, resultCallback);
795         if (OC_STACK_OK != resReq)
796         {
797             if (OC_STACK_CONTINUE == resReq)
798             {
799                 OIC_LOG(INFO, TAG, "OCRemoveDeviceWithUuid : Revoked device has no linked device except PT.");
800             }
801             else
802             {
803                 OIC_LOG(ERROR, TAG, "OCRemoveDeviceWithUuid : Failed to invoke SRPRemoveDevice");
804                 res = resReq;
805                 goto error;
806             }
807         }
808     }
809     else
810     {
811         OIC_LOG_V(INFO, TAG, "There is no linked devices with [%s]", strUuid);
812         OIC_LOG(INFO, TAG, "Device discovery and SRPRemoveDevice will be skipped.");
813     }
814
815     res = RemoveDeviceInfoFromLocal(pTargetDev);
816     if(OC_STACK_OK != res)
817     {
818         OIC_LOG(ERROR, TAG, "OCRemoveDeviceWithUuid : Filed to remove the device information from local.");
819         goto error;
820     }
821
822     if(OC_STACK_CONTINUE == resReq)
823     {
824         /**
825           * If there is no linked device, PM does not send any request.
826           * So we should directly invoke the result callback to inform the result of OCRemoveDevice.
827           */
828         if(resultCallback)
829         {
830             resultCallback(ctx, 0, NULL, false);
831         }
832         res = OC_STACK_OK;
833     }
834
835 error:
836     OICFree(strUuid);
837     PMDeleteDeviceList(pOwnedDevList);
838     if(pTargetDev && false == discoverdFlag)
839     {
840         OICFree(pTargetDev->doxm);
841         OICFree(pTargetDev);
842     }
843     OIC_LOG(INFO, TAG, "OUT OCRemoveDeviceWithUuid");
844     return res;
845 }
846
847 /*
848  * Function to reset the target device.
849  * This function will remove credential and ACL of target device from all devices in subnet.
850  *
851  * @param[in] ctx Application context would be returned in result callback
852  * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
853  * @param[in] pTargetDev Device information to be revoked.
854  * @param[in] resultCallback callback provided by API user, callback will be called when
855  *            credential revocation is finished.
856  * @return  OC_STACK_OK in case of success and other value otherwise.
857  */
858 OCStackResult OCResetDevice(void* ctx, unsigned short waitTimeForOwnedDeviceDiscovery,
859                             const OCProvisionDev_t* pTargetDev,
860                             OCProvisionResultCB resultCallback)
861 {
862     OIC_LOG(INFO, TAG, "IN OCResetDevice");
863     OCStackResult res = OC_STACK_ERROR;
864     if (!pTargetDev || 0 == waitTimeForOwnedDeviceDiscovery)
865     {
866         OIC_LOG(INFO, TAG, "OCResetDevice : Invalid parameters");
867         return OC_STACK_INVALID_PARAM;
868     }
869     if (!resultCallback)
870     {
871         OIC_LOG(INFO, TAG, "OCResetDevice : NULL Callback");
872         return OC_STACK_INVALID_CALLBACK;
873     }
874
875     // Send DELETE requests to linked devices
876     res = SRPSyncDevice(ctx, waitTimeForOwnedDeviceDiscovery, pTargetDev, resultCallback);
877     if (OC_STACK_CONTINUE == res)
878     {
879         OIC_LOG(DEBUG, TAG, "OCResetDevice : Target device has no linked device except PT.");
880         if(resultCallback)
881         {
882             resultCallback(ctx, 0, NULL, false);
883         }
884         SRPResetDevice(pTargetDev, resultCallback);
885         res = OC_STACK_OK;
886     }
887     else if(OC_STACK_OK != res)
888     {
889         OIC_LOG(ERROR, TAG, "OCResetDevice : Failed to invoke SRPSyncDevice");
890     }
891     OIC_LOG(INFO, TAG, "OUT OCResetDevice");
892     return res;
893 }
894
895 /**
896  * This function resets SVR DB to its factory setting.
897  *
898  * @return OC_STACK_OK in case of successful reset and other value otherwise.
899  */
900 OCStackResult OCResetSVRDB(void)
901 {
902     return ResetSecureResourceInPS();
903 }
904
905 /**
906  * This function configures SVR DB as self-ownership.
907  *
908  *@return OC_STACK_OK in case of successful configue and other value otherwise.
909  */
910 OCStackResult OCConfigSelfOwnership(void)
911 {
912     return ConfigSelfOwnership();
913 }
914
915 /**
916  * Internal Function to update result in link result array.
917  */
918 static void UpdateLinkResults(Linkdata_t *link, int device, OCStackResult stackresult)
919 {
920
921     OIC_LOG_V(INFO,TAG,"value of link->currentCountResults is %d",link->currentCountResults);
922     if (1 == device)
923     {
924         memcpy(link->resArr[(link->currentCountResults)].deviceId.id, link->pDev1->doxm->deviceID.id,UUID_LENGTH);
925     }
926     else
927     {
928         memcpy(link->resArr[(link->currentCountResults)].deviceId.id, link->pDev2->doxm->deviceID.id,UUID_LENGTH);
929     }
930     link->resArr[(link->currentCountResults)].res = stackresult;
931     ++(link->currentCountResults);
932
933 }
934
935 /**
936  * Callback to handle ACL provisioning for device 2.
937  */
938 static void AclProv2CB(void* ctx, int nOfRes, OCProvisionResult_t *arr, bool hasError)
939 {
940
941     if (NULL == ctx)
942     {
943         OIC_LOG(ERROR,TAG,"Context is Null in ACLProv 2");
944         return;
945     }
946     (void)nOfRes;
947     Linkdata_t *link = (Linkdata_t*)ctx;
948     OCProvisionResultCB resultCallback = link->resultCallback;
949
950
951     if (hasError)
952     {
953         UpdateLinkResults(link, 2,arr[0].res);
954         OIC_LOG(ERROR,TAG,"Error occured while ACL provisioning device 1");
955         ((OCProvisionResultCB)(resultCallback))(link->ctx, link->currentCountResults,
956                                                 link->resArr,
957                                                 true);
958         OICFree(link->resArr);
959         OICFree(link) ;
960         return;
961     }
962     UpdateLinkResults(link, 2, arr[0].res);
963    ((OCProvisionResultCB)(resultCallback))(link->ctx, link->currentCountResults,
964                                            link->resArr,
965                                            false);
966     OICFree(link->resArr);
967     OICFree(link);
968     return;
969 }
970
971 /**
972  * Callback to handle ACL provisioning for device 1
973  */
974 static void AclProv1CB(void* ctx, int nOfRes, OCProvisionResult_t *arr, bool hasError)
975 {
976
977     if (NULL == ctx)
978     {
979         OIC_LOG(ERROR,TAG,"Context is Null in ACLProv1");
980         return;
981     }
982     (void)nOfRes;
983     Linkdata_t *link = (Linkdata_t*)ctx;
984     OCProvisionResultCB resultCallback = link->resultCallback;
985
986     if (hasError)
987     {
988         OIC_LOG(ERROR,TAG,"Error occured while ACL provisioning device 1");
989         UpdateLinkResults(link, 1, arr[0].res);
990         ((OCProvisionResultCB)(resultCallback))(link->ctx, link->currentCountResults,
991                                                 link->resArr,
992                                                 true);
993         OICFree(link->resArr);
994         OICFree(link);
995         return;
996     }
997     UpdateLinkResults(link, 1, arr[0].res);
998     if (NULL != link->pDev2Acl)
999     {
1000         OCStackResult res =  SRPProvisionACL(ctx, link->pDev2, link->pDev2Acl, &AclProv2CB);
1001         if (OC_STACK_OK!=res)
1002         {
1003              UpdateLinkResults(link, 2, res);
1004              ((OCProvisionResultCB)(resultCallback))(link->ctx, link->currentCountResults,
1005                                                      link->resArr,
1006                                                      true);
1007
1008         }
1009     }
1010     else
1011     {
1012         ((OCProvisionResultCB)(resultCallback))(link->ctx, link->currentCountResults,
1013                                                 link->resArr,
1014                                                 false);
1015         OICFree(link->resArr);
1016         OICFree(link);
1017     }
1018
1019     return;
1020 }
1021
1022 /**
1023  * Callback to handle credential provisioning.
1024  */
1025 static void ProvisionCredsCB(void* ctx, int nOfRes, OCProvisionResult_t *arr, bool hasError)
1026 {
1027     if (NULL == ctx)
1028     {
1029         OIC_LOG(ERROR,TAG,"Error occured while credential provisioning");
1030         return;
1031     }
1032     Linkdata_t *link = (Linkdata_t*)ctx;
1033     OCProvisionResultCB resultCallback = link->resultCallback;
1034     OIC_LOG_V(INFO, TAG, "has error returned %d",hasError);
1035     UpdateLinkResults(link, 1, arr[0].res);
1036     UpdateLinkResults(link, 2, arr[1].res);
1037     if (hasError)
1038     {
1039         OIC_LOG(ERROR,TAG,"Error occured while credential provisioning");
1040         ((OCProvisionResultCB)(resultCallback))(link->ctx, nOfRes,
1041                                                 link->resArr,
1042                                                 true);
1043          OICFree(link->resArr);
1044          OICFree(link);
1045          return;
1046     }
1047     if (NULL != link->pDev1Acl)
1048     {
1049
1050         OCStackResult res =  SRPProvisionACL(ctx, link->pDev1, link->pDev1Acl, &AclProv1CB);
1051         if (OC_STACK_OK!=res)
1052         {
1053              OIC_LOG(ERROR, TAG, "Error while provisioning ACL for device 1");
1054              UpdateLinkResults(link, 1, res);
1055              ((OCProvisionResultCB)(resultCallback))(link->ctx, link->currentCountResults,
1056                                                      link->resArr,
1057                                                      true);
1058               OICFree(link->resArr);
1059               OICFree(link);
1060         }
1061     }
1062     else if (NULL!=link->pDev2Acl)
1063     {
1064         OIC_LOG(ERROR, TAG, "ACL for device 1 is NULL");
1065         OCStackResult res =  SRPProvisionACL(ctx, link->pDev2, link->pDev2Acl, &AclProv2CB);
1066         if (OC_STACK_OK!=res)
1067         {
1068              OIC_LOG(ERROR, TAG, "Error while provisioning ACL for device 2");
1069               UpdateLinkResults(link, 2, res);
1070              ((OCProvisionResultCB)(resultCallback))(link->ctx, link->currentCountResults,
1071                                                      link->resArr,
1072                                                      true);
1073               OICFree(link->resArr);
1074               OICFree(link);
1075         }
1076     }
1077     else
1078     {
1079         OIC_LOG(INFO, TAG, "ACLs of both devices are NULL");
1080         ((OCProvisionResultCB)(resultCallback))(link->ctx, link->currentCountResults,
1081                                                 link->resArr,
1082                                                 false);
1083         OICFree(link->resArr);
1084         OICFree(link);
1085     }
1086     return;
1087 }
1088 /**
1089  * function to provision credentials between two devices and ACLs for the devices who act as a server.
1090  *
1091  * @param[in] ctx Application context would be returned in result callback.
1092  * @param[in] type Type of credentials to be provisioned to the device.
1093  * @param[in] pDev1 Pointer to OCProvisionDev_t instance,respresenting resource to be provsioned.
1094  * @param[in] acl ACL for device 1. If this is not required set NULL.
1095  * @param[in] pDev2 Pointer to OCProvisionDev_t instance,respresenting resource to be provsioned.
1096  * @param[in] acl ACL for device 2. If this is not required set NULL.
1097  * @param[in] resultCallback callback provided by API user, callback will be called when
1098  *            provisioning request recieves a response from first resource server.
1099  * @return  OC_STACK_OK in case of success and other value otherwise.
1100  */
1101 OCStackResult OCProvisionPairwiseDevices(void* ctx, OicSecCredType_t type, size_t keySize,
1102                                          const OCProvisionDev_t *pDev1, OicSecAcl_t *pDev1Acl,
1103                                          const OCProvisionDev_t *pDev2, OicSecAcl_t *pDev2Acl,
1104                                          OCProvisionResultCB resultCallback)
1105 {
1106
1107     if (!pDev1 || !pDev2 || !pDev1->doxm || !pDev2->doxm)
1108     {
1109         OIC_LOG(ERROR, TAG, "OCProvisionPairwiseDevices : Invalid parameters");
1110         return OC_STACK_INVALID_PARAM;
1111     }
1112     if (!resultCallback)
1113     {
1114         OIC_LOG(INFO, TAG, "OCProvisionPairwiseDevices : NULL Callback");
1115         return OC_STACK_INVALID_CALLBACK;
1116     }
1117     if (!(keySize == OWNER_PSK_LENGTH_128 || keySize == OWNER_PSK_LENGTH_256))
1118     {
1119         OIC_LOG(INFO, TAG, "OCProvisionPairwiseDevices : Invalid key size");
1120         return OC_STACK_INVALID_PARAM;
1121     }
1122     if (0 == memcmp(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, sizeof(OicUuid_t)))
1123     {
1124         OIC_LOG(INFO, TAG, "OCProvisionPairwiseDevices : Same device ID");
1125         return OC_STACK_INVALID_PARAM;
1126     }
1127
1128     OIC_LOG(DEBUG, TAG, "Checking link in DB");
1129     bool linkExists = true;
1130     OCStackResult res = PDMIsLinkExists(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, &linkExists);
1131     if(res != OC_STACK_OK)
1132     {
1133         OIC_LOG(ERROR, TAG, "Internal Error Occured");
1134         return res;
1135     }
1136     if (linkExists)
1137     {
1138         OIC_LOG(ERROR, TAG, "Link already exists");
1139         return OC_STACK_INVALID_PARAM;
1140     }
1141
1142     int noOfResults = 2; // Initial Value
1143     if (NULL != pDev1Acl)
1144     {
1145         ++noOfResults;
1146     }
1147     if (NULL != pDev2Acl)
1148     {
1149        ++noOfResults;
1150     }
1151     Linkdata_t *link = (Linkdata_t*) OICMalloc(sizeof(Linkdata_t));
1152     if (!link)
1153     {
1154         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1155         return OC_STACK_NO_MEMORY;
1156     }
1157     OIC_LOG_V(INFO,TAG, "Maximum no od results %d",noOfResults);
1158
1159     link->pDev1 = pDev1;
1160     link->pDev1Acl = pDev1Acl;
1161     link->pDev2 = pDev2;
1162     link->pDev2Acl = pDev2Acl;
1163     link->ctx = ctx;
1164     // 1 call for each device for credential provisioning. implict call by SRPProvisioning credential
1165     // 1 call for ACL provisioning for device 1 and 1 call for ACL provisioning for device 2.
1166     link->numOfResults = noOfResults;
1167     link->resultCallback = resultCallback;
1168     link->currentCountResults = 0;
1169     link->resArr = (OCProvisionResult_t*) OICMalloc(sizeof(OCProvisionResult_t)*noOfResults);
1170     res = SRPProvisionCredentials(link, type, keySize,
1171                                      pDev1, pDev2, &ProvisionCredsCB);
1172     if (res != OC_STACK_OK)
1173     {
1174         OICFree(link->resArr);
1175         OICFree(link);
1176     }
1177     return res;
1178
1179 }
1180
1181 OCStackResult OCGetDevInfoFromNetwork(unsigned short waittime,
1182                                        OCProvisionDev_t** pOwnedDevList,
1183                                        OCProvisionDev_t** pUnownedDevList)
1184 {
1185     //TODO will be replaced by more efficient logic
1186     if (pOwnedDevList == NULL || *pOwnedDevList != NULL || pUnownedDevList == NULL
1187          || *pUnownedDevList != NULL || 0 == waittime)
1188     {
1189         return OC_STACK_INVALID_PARAM;
1190     }
1191
1192     // Code for unowned discovery
1193     OCProvisionDev_t *unownedDevice = NULL;
1194     OCStackResult res =  OCDiscoverUnownedDevices(waittime/2, &unownedDevice);
1195     if (OC_STACK_OK != res)
1196     {
1197         OIC_LOG(ERROR,TAG, "Error in unowned discovery");
1198         return res;
1199     }
1200
1201     // Code for owned discovery
1202     OCProvisionDev_t *ownedDevice = NULL;
1203     res =  OCDiscoverOwnedDevices(waittime/2, &ownedDevice);
1204     if (OC_STACK_OK != res)
1205     {
1206         OIC_LOG(ERROR,TAG, "Error in owned discovery");
1207         PMDeleteDeviceList(unownedDevice);
1208         return res;
1209     }
1210
1211     // Code to get list of all the owned devices.
1212     OCUuidList_t *uuidList = NULL;
1213     size_t numOfDevices = 0;
1214     res =  PDMGetOwnedDevices(&uuidList, &numOfDevices);
1215     if (OC_STACK_OK != res)
1216     {
1217         OIC_LOG(ERROR, TAG, "Error while getting info from DB");
1218         PMDeleteDeviceList(unownedDevice);
1219         PMDeleteDeviceList(ownedDevice);
1220         return res;
1221     }
1222
1223     // Code to compare devices in unowned list and deviceid from DB
1224     // (In case of hard reset of the device)
1225     OCProvisionDev_t* pUnownedList = unownedDevice;
1226     while (pUnownedList && uuidList)
1227     {
1228         OCUuidList_t *tmp1 = NULL,*tmp2=NULL;
1229         LL_FOREACH_SAFE(uuidList, tmp1, tmp2)
1230         {
1231             if(0 == memcmp(tmp1->dev.id, pUnownedList->doxm->deviceID.id,
1232                             sizeof(pUnownedList->doxm->deviceID.id)))
1233             {
1234                 OIC_LOG_V(INFO, TAG, "OCGetDevInfoFromNetwork : \
1235                             Removing device id = %s in PDM and dat.", pUnownedList->doxm->deviceID.id);
1236                 if (OC_STACK_OK != PDMDeleteDevice(&pUnownedList->doxm->deviceID))
1237                 {
1238                     OIC_LOG(ERROR, TAG, "OCGetDevInfoFromNetwork : \
1239                             Failed to remove device in PDM.");
1240                 }
1241                 //remove the cred entry from dat file
1242                 if (OC_STACK_OK != RemoveDeviceInfoFromLocal(pUnownedList))
1243                 {
1244                     OIC_LOG(ERROR, TAG, "OCGetDevInfoFromNetwork : \
1245                             Failed to remove cred entry device in dat file.");
1246                 }
1247                 LL_DELETE(uuidList, tmp1);
1248                 OICFree(tmp1);
1249             }
1250         }
1251         pUnownedList = pUnownedList->next;
1252     }
1253     // Code to compare devices in owned list and deviceid from DB.
1254     OCProvisionDev_t* pCurDev = ownedDevice;
1255     size_t deleteCnt = 0;
1256     while (pCurDev)
1257     {
1258         if(true == PMDeleteFromUUIDList(&uuidList, &pCurDev->doxm->deviceID))
1259         {
1260             deleteCnt++;
1261         }
1262         pCurDev = pCurDev->next;
1263     }
1264     // If there is no remaind device in uuidList, we have to assign NULL to prevent free.
1265     if (deleteCnt == numOfDevices)
1266     {
1267         uuidList = NULL;
1268     }
1269     // Code to add information of the devices which are currently off in owned list.
1270     OCUuidList_t *powerOffDeviceList = uuidList;
1271     while (powerOffDeviceList)
1272     {
1273         OCProvisionDev_t *ptr = (OCProvisionDev_t *)OICCalloc(1, sizeof (OCProvisionDev_t));
1274         if (NULL == ptr)
1275         {
1276             OIC_LOG(ERROR,TAG,"Fail to allocate memory");
1277             PMDeleteDeviceList(unownedDevice);
1278             PMDeleteDeviceList(ownedDevice);
1279             OCDeleteUuidList(uuidList);
1280             return OC_STACK_NO_MEMORY;
1281         }
1282
1283         ptr->doxm = (OicSecDoxm_t*)OICCalloc(1, sizeof(OicSecDoxm_t));
1284         if (NULL == ptr->doxm)
1285         {
1286             OIC_LOG(ERROR,TAG,"Fail to allocate memory");
1287             PMDeleteDeviceList(unownedDevice);
1288             PMDeleteDeviceList(ownedDevice);
1289             OCDeleteUuidList(uuidList);
1290             OICFree(ptr);
1291             return OC_STACK_NO_MEMORY;
1292         }
1293
1294         memcpy(ptr->doxm->deviceID.id, powerOffDeviceList->dev.id, sizeof(ptr->doxm->deviceID.id));
1295
1296         ptr->devStatus = DEV_STATUS_OFF;
1297         LL_PREPEND(ownedDevice, ptr);
1298         powerOffDeviceList = powerOffDeviceList->next;
1299
1300     }
1301     OCDeleteUuidList(uuidList);
1302     *pOwnedDevList = ownedDevice;
1303     *pUnownedDevList = unownedDevice;
1304     return OC_STACK_OK;
1305 }
1306
1307 OCStackResult OCGetLinkedStatus(const OicUuid_t* uuidOfDevice, OCUuidList_t** uuidList,
1308                                  size_t* numOfDevices)
1309 {
1310     return PDMGetLinkedDevices(uuidOfDevice, uuidList, numOfDevices);
1311 }
1312
1313 void OCDeleteUuidList(OCUuidList_t* pList)
1314 {
1315     PDMDestoryOicUuidLinkList(pList);
1316 }
1317
1318 /**
1319  * This function deletes ACL data.
1320  *
1321  * @param pAcl Pointer to OicSecAcl_t structure.
1322  */
1323 void OCDeleteACLList(OicSecAcl_t* pAcl)
1324 {
1325     DeleteACLList(pAcl);
1326 }
1327
1328 /**
1329  * This function deletes PDACL data.
1330  *
1331  * @param pPdAcl Pointer to OicSecPdAcl_t structure.
1332  */
1333 void OCDeletePdAclList(OicSecPdAcl_t* pPdAcl)
1334 {
1335     FreePdAclList(pPdAcl);
1336 }
1337
1338 #ifdef MULTIPLE_OWNER
1339 /**
1340  * API to update 'doxm.mom' to resource server.
1341  *
1342  * @param[in] targetDeviceInfo Selected target device.
1343  * @param[in] momType Mode of multiple ownership transfer (ref. oic.sec.mom)
1344  * @param[in] resultCallback callback provided by API user, callback will be called when
1345  *            POST 'mom' request recieves a response from resource server.
1346  * @return OC_STACK_OK in case of success and other value otherwise.
1347  */
1348 OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo,
1349                             const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1350 {
1351     return MOTChangeMode(ctx, targetDeviceInfo, momType, resultCallback);
1352 }
1353
1354 /**
1355  * API to update 'doxm.oxmsel' to resource server.
1356  *
1357  * @param[in] targetDeviceInfo Selected target device.
1358   * @param[in] oxmSelValue Method of multiple ownership transfer (ref. oic.sec.oxm)
1359  * @param[in] resultCallback callback provided by API user, callback will be called when
1360  *            POST 'oxmsel' request recieves a response from resource server.
1361  * @return OC_STACK_OK in case of success and other value otherwise.
1362  */
1363 OCStackResult OCSelectMOTMethod(void *ctx, const OCProvisionDev_t *targetDeviceInfo,
1364                                  const OicSecOxm_t oxmSelValue, OCProvisionResultCB resultCallback)
1365 {
1366     return MOTSelectMOTMethod(ctx, targetDeviceInfo, oxmSelValue, resultCallback);
1367 }
1368 #endif //MULTIPLE_OWNER
1369
1370 /**
1371  * Function to select appropriate security provisioning method.
1372  *
1373  * @param[in] supportedMethods   Array of supported methods
1374  * @param[in] numberOfMethods   number of supported methods
1375  * @param[out]  selectedMethod         Selected methods
1376  * @param[in] ownerType type of owner device (SUPER_OWNER or SUB_OWNER)
1377  * @return  OC_STACK_OK on success
1378  */
1379 OCStackResult OCSelectOwnershipTransferMethod(const OicSecOxm_t *supportedMethods,
1380         size_t numberOfMethods, OicSecOxm_t *selectedMethod, OwnerType_t ownerType)
1381 {
1382     return OTMSelectOwnershipTransferMethod(supportedMethods, numberOfMethods,
1383                                             selectedMethod, ownerType);
1384 }
1385
1386 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
1387 /**
1388  * function to provision Trust certificate chain to devices.
1389  *
1390  * @param[in] ctx Application context would be returned in result callback.
1391  * @param[in] type Type of credentials to be provisioned to the device.
1392  * @param[in] credId CredId of trust certificate chain to be provisioned to the device.
1393  * @param[in] selectedDeviceInfo Pointer to OCProvisionDev_t instance,respresenting resource to be provsioned.
1394  * @param[in] resultCallback callback provided by API user, callback will be called when
1395  *            provisioning request recieves a response from first resource server.
1396  * @return  OC_STACK_OK in case of success and other value otherwise.
1397  */
1398 OCStackResult OCProvisionTrustCertChain(void *ctx, OicSecCredType_t type, uint16_t credId,
1399                                       const OCProvisionDev_t *selectedDeviceInfo,
1400                                       OCProvisionResultCB resultCallback)
1401 {
1402     return SRPProvisionTrustCertChain(ctx, type, credId,
1403                                       selectedDeviceInfo, resultCallback);
1404 }
1405
1406 /**
1407  * function to save Trust certificate chain into Cred of SVR.
1408  *
1409  * @param[in] trustCertChain Trust certificate chain to be saved in Cred of SVR.
1410  * @param[in] chainSize Size of trust certificate chain to be saved in Cred of SVR
1411  * @param[in] encodingType Encoding type of trust certificate chain to be saved in Cred of SVR
1412  * @param[out] credId CredId of saved trust certificate chain in Cred of SVR.
1413  * @return  OC_STACK_OK in case of success and other value otherwise.
1414  */
1415 OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize,
1416                                     OicEncodingType_t encodingType, uint16_t *credId)
1417 {
1418     return SRPSaveTrustCertChain(trustCertChain, chainSize, encodingType, credId);
1419 }
1420
1421 /**
1422  * function to register notifier for Trustcertchain change.
1423  *
1424  * @param[in] ctx user context.
1425  * @param[in] TrustCertChainChangeCB notification callback fucntion.
1426  * @return    OC_STACK_OK in case of success and other value otherwise.
1427  */
1428 OCStackResult OCRegisterTrustCertChainNotifier(void *ctx, TrustCertChainChangeCB Callback)
1429 {
1430     return SRPRegisterTrustCertChainNotifier(ctx, Callback);
1431 }
1432
1433 /**
1434  * function to de-register notifier for Trustcertchain change.
1435  */
1436 void OCRemoveTrustCertChainNotifier()
1437 {
1438     SRPRemoveTrustCertChainNotifier();
1439 }
1440
1441 /**
1442  * This function sets the callback to utilize peer certificate information
1443  */
1444 OCStackResult OCSetPeerCertCallback(void *ctx, PeerCertCallback peerCertCallback)
1445 {
1446     CAResult_t ret;
1447
1448     OIC_LOG_V(DEBUG, TAG, "IN %s", __func__);
1449     ret = CAsetPeerCertCallback(ctx, peerCertCallback);
1450     if (CA_STATUS_OK != ret)
1451     {
1452         OIC_LOG_V(ERROR, TAG, "CAsetPeerCertCallback() Failed(%d)", ret);
1453         return OC_STACK_ERROR;
1454     }
1455     OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__);
1456
1457     return OC_STACK_OK;
1458 }
1459
1460 #endif // __WITH_DTLS__ || __WITH_TLS__
1461