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