7fdb50b950d177531e27b3305a02f19b2fa85f89
[iotivity.git] / resource / include / OCProvisioningManager.hpp
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
21 #ifndef OC_PROVISIONINGMANAGER_CXX_H_
22 #define OC_PROVISIONINGMANAGER_CXX_H_
23
24 #include <thread>
25
26 #include "pinoxmcommon.h"
27 #include "ocprovisioningmanager.h"
28 #include "OCApi.h"
29 #include "OCPlatform_impl.h"
30 #include "oxmverifycommon.h"
31 #include "securevirtualresourcetypes.h"
32
33 namespace OC
34 {
35     class OCSecureResource;
36
37     typedef std::vector<std::shared_ptr<OCSecureResource>> DeviceList_t;
38     typedef std::vector<OicUuid_t> UuidList_t;
39     typedef std::vector<OCProvisionResult_t> PMResultList_t;
40     typedef std::function<void(PMResultList_t *result, int hasError)> ResultCallBack;
41     typedef std::function<void(uint16_t credId, uint8_t *trustCertChain,
42             size_t chainSize)>CertChainCallBack;
43     typedef std::function<OCStackResult(uint8_t verifNum[])> DisplayNumCB;
44     typedef std::function<OCStackResult()> UserConfirmNumCB;
45     typedef std::function<void(char* pinData, size_t pinSize)> DisplayPinCB;
46     typedef std::function<void(OicUuid_t deviceId, char* pinBuffer, size_t pinBufferSize)> InputPinCB;
47
48     struct ProvisionContext
49     {
50         ResultCallBack callback;
51         ProvisionContext(ResultCallBack cb) : callback(cb){}
52     };
53
54     struct TrustCertChainContext
55     {
56         CertChainCallBack callback;
57         TrustCertChainContext(CertChainCallBack cb) : callback(cb){}
58     };
59
60     struct DisplayPinContext
61     {
62         DisplayPinCB callback;
63         DisplayPinContext(DisplayPinCB cb) : callback(cb) {}
64     };
65
66     struct InputPinContext
67     {
68         InputPinCB callback;
69         InputPinContext(InputPinCB cb) : callback(cb) {}
70     };
71
72     struct DisplayNumContext
73     {
74         DisplayNumCB callback;
75         DisplayNumContext(DisplayNumCB cb) : callback(cb){}
76     };
77
78     struct UserConfirmNumContext
79     {
80         UserConfirmNumCB callback;
81         UserConfirmNumContext(UserConfirmNumCB cb) : callback(cb){}
82     };
83
84     typedef InputPinContext* InputPinCallbackHandle;
85     typedef DisplayPinContext* DisplayPinCallbackHandle;
86
87     /**
88      * This class is for credential's to be set to devices.
89      * The types supported are
90      *              0:  no security mode
91      *              1:  symmetric pair-wise key
92      *              2:  symmetric group key
93      *              4:  asymmetric key
94      *              8:  signed asymmetric key (aka certificate)
95      *              16: PIN /password
96      */
97     class Credential
98     {
99             OicSecCredType_t m_type;
100             size_t m_keySize;
101         public:
102             Credential() = default;
103             Credential(OicSecCredType_t type, size_t size) : m_type(type), m_keySize(size)
104             {}
105
106             /**
107              * API to get credential type of device.
108              * @return credential type of device.
109              */
110             OicSecCredType_t getCredentialType() const
111             {
112                 return m_type;
113             }
114
115             /**
116              * API to get size of credential key type.
117              * @return size of credential key type.
118              */
119             size_t getCredentialKeySize() const
120             {
121                 return m_keySize;
122             }
123
124             /**
125              * API to set credential type of device.
126              * Device can have following credential types
127              *  - symmetric pair-wise key
128              *  - symmetric group key
129              *  - asymmetric key
130              *  - signed asymmetric key (aka certificate)
131              *  - PIN /password
132              * @param type credential type.
133              */
134             void setCredentialType(OicSecCredType_t type)
135             {
136                 this->m_type = type;
137             }
138
139             /**
140              * API to set size of credential key type.
141              * @param keySize credential key size.
142              * @note can be either 128 or 256 for symmetric pair-wise key
143              */
144             void setCredentialKeySize(size_t keySize)
145             {
146                 this->m_keySize = keySize;
147             }
148     };
149
150     class OCSecure
151     {
152         private:
153             /**
154              * Common callback wrapper, which will be called from OC-APIs.
155              */
156             static void callbackWrapper(void* ctx, size_t nOfRes,
157                                          OCProvisionResult_t *arr, bool hasError);
158
159             /**
160              * Callback function to display Verification Number.
161              *
162              * @param[in] ctx  User context returned in callback
163              * @param[in] verifNum  Array of MUTUAL_VERIF_NUM_LEN size bytes
164              *
165              * @return OC_STACK_OK in case of success and other value otherwise.
166              */
167             static OCStackResult OC_CALL displayNumCallbackWrapper(void* ctx,
168                     uint8_t verifNum[MUTUAL_VERIF_NUM_LEN]);
169
170             /**
171              * Callback function to get 'Num' verification result.
172              *
173              * @return OC_STACK_OK in case of success and other value otherwise.
174              */
175             static OCStackResult OC_CALL confirmUserCallbackWrapper(void* ctx);
176
177             /**
178              * Notifier wrapper for trustCertChain change.
179              *
180              * @param[in] ctx  User context returned in callback
181              * @param[in] credId  trustCertChain changed for this ID
182              * @param[in] trustCertChain trustcertchain binary blob
183              * @param[in] chainSize size of trustCertChain
184              */
185             static void certCallbackWrapper(void* ctx, uint16_t credId, uint8_t *trustCertChain,
186                                 size_t chainSize);
187
188         public:
189             /**
190              * The API is responsible for initialization of the provisioning manager. It will load
191              * provisioning database which have owned device's list and their linked status.
192              *
193              * @param dbPath file path of the sqlite3 database.
194              *
195              * @return ::OC_STACK_OK in case of success and other value otherwise.
196              */
197             static OCStackResult provisionInit(const std::string& dbPath);
198
199             /**
200              * API is responsible for discovery of devices in it's subnet. It will list
201              * all the device in subnet which are not yet owned.
202              *
203              * @param timeout Timeout in seconds, time until which function will listen to
204              *                    responses from server before returning the list of devices.
205              * @param list List of candidate devices to be provisioned.
206              * @return ::OC_STACK_OK in case of success and other value otherwise.
207              */
208             static OCStackResult discoverUnownedDevices(unsigned short timeout,
209                     DeviceList_t &list);
210
211             /**
212              * API is responsible for discovery of devices in it's subnet. It will list
213              * all the device in subnet which are already owned by calling provisioning client.
214              *
215              * @param timeout Timeout in seconds, time until which function will listen to
216              *                    responses from server before returning the list of devices.
217              * @param list List of owned devices.
218              * @return ::OC_STACK_OK in case of success and other value otherwise.
219              */
220             static OCStackResult discoverOwnedDevices(unsigned short timeout,
221                     DeviceList_t &list);
222
223             /**
224              * API is responsible for discovery of devices in specified endpoint/deviceID.
225              * And this function will only return the specified device's response.
226              *
227              * @param timeout Timeout in seconds, time until which function will listen to
228              *                    responses from server before returning the specified device.
229              * @param deviceID  deviceID of target device
230              * @param foundDevice OCSecureResource object of found device.
231              * @return ::OC_STACK_OK in case of success and other value otherwise.\n
232              *         ::OC_STACK_INVALID_PARAM when deviceID is NULL or ppFoundDevice is not
233              *                                  initailized.
234              */
235             static OCStackResult discoverSingleDevice(unsigned short timeout,
236                     const OicUuid_t* deviceID,
237                     std::shared_ptr<OCSecureResource> &foundDevice);
238
239             /**
240              * API for registering Ownership transfer methods for a particular transfer Type.
241              * @deprecated Use setInputPinCallback to set input pin callback value.
242              *
243              * @param oxm Ownership transfer method.
244              * @param callbackData CallbackData Methods for ownership transfer.
245              * @param inputPin Callback method to input pin for verification.
246              * @return ::OC_STACK_OK in case of success and other value otherwise.
247              *
248              */
249             static OCStackResult setOwnerTransferCallbackData(OicSecOxm_t oxm,
250                     OTMCallbackData_t* callbackData, InputPinCallback inputPin);
251
252             /**
253              * API is responsible for discovery of devices in specified endpoint/deviceID.
254              * And this function will only return the specified device's response.
255              *
256              * @param timeout Timeout in seconds, time until which function will listen to
257              *                    responses from server before returning the specified device.
258              * @param deviceID  deviceID of target device.
259              * @param hostAddress  MAC address of target device.
260              * @param connType  ConnectivityType for discovery.
261              * @param foundDevice OCSecureResource object of found device.
262              * @return ::OC_STACK_OK in case of success and other value otherwise.
263              *         ::OC_STACK_INVALID_PARAM when deviceID is NULL or ppFoundDevice is not
264              *                                  initailized.
265              */
266             static OCStackResult discoverSingleDeviceInUnicast(unsigned short timeout,
267                     const OicUuid_t* deviceID,
268                     const std::string& hostAddress,
269                     OCConnectivityType connType,
270                     std::shared_ptr<OCSecureResource> &foundDevice);
271
272 #ifdef MULTIPLE_OWNER
273              /**
274              * API is responsible for discovery of MOT(Mutilple Owner Transfer)
275              * devices in current subnet.
276              *
277              * @param timeout Timeout in seconds, time until which function will listen to
278              *                    responses from server before returning the list of devices.
279              * @param list List of MOT enabled devices.
280              * @return ::OC_STACK_OK in case of success and other value otherwise.
281              */
282             static OCStackResult discoverMultipleOwnerEnabledDevices(unsigned short timeout,
283                     DeviceList_t &list);
284
285              /**
286              * API is responsible for discovery of Multiple owned device in
287              * current subnet.
288              *
289              * @param timeout Timeout in seconds, time until which function will listen to
290              *                    responses from server before returning the list of devices.
291              * @param list List of Multiple Owned devices.
292              * @return ::OC_STACK_OK in case of success and other value otherwise.
293              */
294             static OCStackResult discoverMultipleOwnedDevices(unsigned short timeout,
295                     DeviceList_t &list);
296
297             /**
298              * API is responsible for discovery of a MOT enabled device with a specified deviceID.
299              * The function will return when security information for device with deviceID has been
300              * obtained or the timeout has been exceeded.
301              *
302              * @param timeout      Maximum time, in seconds, this function will listen for responses
303              *                     from servers before returning.
304              * @param deviceID     deviceID of target device
305              * @param foundDevice  OCSecureResource object of found device.
306              * @return ::OC_STACK_OK in case of success and other value otherwise.
307              *         ::OC_STACK_INVALID_PARAM when deviceID is NULL or ppFoundDevice is not
308              *                                  initailized.
309              */
310             static OCStackResult discoverMultipleOwnerEnabledDevice(unsigned short timeout,
311                     const OicUuid_t* deviceID,
312                     std::shared_ptr<OCSecureResource> &foundDevice);
313
314 #endif
315
316             /**
317              * API for registering a pin input callback. Only one input pin callback is allowed
318              * to be registered at a time by setInputPinCallback and registerInputPinCallback.
319              * Use unsetInputPinCallback to unregister a callback set by setInputPinCallback.
320              *
321              * @deprecated Use registerInputPinCallback instead.
322              *
323              * @param inputPin inputPin callback function.
324              * @return OC_STACK_OK in case of success and other value otherwise.
325              *         OC_STACK_INVALID_CALLBACK if inputPin is invalid.
326              *         OC_STACK_DUPLICATE_REQUEST if an input pin callback has already been set.
327              */
328             static OCStackResult setInputPinCallback(InputPinCallback inputPin);
329
330             /**
331              * API for de-registering a pin callback.
332              *
333              * @deprecated Use deregisterInputPinCallback instead.
334              *
335              * @return ::OC_STACK_OK in case of success and other value otherwise.
336              */
337             static OCStackResult unsetInputPinCallback();
338
339             /**
340              * API to register for a callback to input a pin. Only one input pin callback is allowed
341              * to be registered at a time by setInputPinCallback and registerInputPinCallback. Use
342              * deregisterInputPinCallback to unregister a callback set by registerInputPinCallback.
343              *
344              * @param inputPinCB             Callback which is to be registered.
345              * @param inputPinCallbackHandle Pointer to a handle that can be used to deregister the callback.
346              * @return  OC_STACK_OK in case of success and other values otherwise.
347              *          OC_STACK_INVALID_CALLBACK if inputPinCB is invalid.
348              *          OC_STACK_INVALID_PARAM if inputPinCallbackHandle is invalid.
349              *          OC_STACK_DUPLICATE_REQUEST if an input pin callback has already been set.
350              */
351             static OCStackResult registerInputPinCallback(InputPinCB inputPinCB, InputPinCallbackHandle* inputPinCallbackHandle);
352
353             /**
354              * API to de-register the callback to input a pin.
355              *
356              * @param inputPinCallbackHandle Handle specifying which callback to deregister.
357              * @return OC_STACK_OK in case of success and other value otherwise.
358              */
359             static OCStackResult deregisterInputPinCallback(InputPinCallbackHandle inputPinCallbackHandle);
360
361             /**
362              * API to register a callback to display the stack generated PIN. Only one display pin callback
363              * is allowed to be registered at a time by setDisplayPinCB and registerDisplayPinCallback.
364              * Use unsetDisplayPinCB to unregister a callback set by setDisplayPinCB.
365              *
366              * @deprecated Use registerDisplayPinCallback instead.
367              *
368              * @param displayPin Callback method to display a generated pin.
369              * @return OC_STACK_OK in case of success and other value otherwise.
370              *         OC_STACK_INVALID_CALLBACK if displayPin is invalid.
371              *         OC_STACK_DUPLICATE_REQUEST if a display pin callback has already been set.
372              */
373             static OCStackResult setDisplayPinCB(GeneratePinCallback displayPin);
374
375             /**
376              * API for de-registering the display pin callback.
377              *
378              * @deprecated Use deregisterDisplayPinCallback instead.
379              *
380              * @return ::OC_STACK_OK in case of success and other value otherwise.
381              */
382             static OCStackResult unsetDisplayPinCB();
383
384             /**
385              * API to set Pin Type policy.
386              *
387              * @param  pinSize pin Size
388              * @param  pinType Type of the pin.
389              * @return OC_STACK_OK in case of success and other value otherwise.
390              */
391             static OCStackResult setRandomPinPolicy(size_t pinSize, OicSecPinType_t pinType);
392
393             /**
394              * API to register for a callback to display a pin. Only one display pin callback is
395              * allowed to be registered at a time by setDisplayPinCB and registerDisplayPinCallback.
396              * Use deregisterDisplayPinCallback to unregister a callback set by registerDisplayPinCallback.
397              *
398              * @param displayPinCB             Callback which is to be registered.
399              * @param displayPinCallbackHandle Pointer to a handle that can be used to deregister the callback.
400              * @return  OC_STACK_OK in case of success and other value otherwise.
401              *          OC_STACK_INVALID_CALLBACK if displayPinCB is invalid.
402              *          OC_STACK_INVALID_PARAM if displayPinCallbackHandle is invalid.
403              *          OC_STACK_DUPLICATE_REQUEST if a display pin callback has already been set.
404              */
405             static OCStackResult registerDisplayPinCallback(DisplayPinCB displayPinCB, DisplayPinCallbackHandle* displayPinCallbackHandle);
406
407             /**
408              * API to de-register the callback to display a pin.
409              *
410              * @param displayPinCallbackHandle Handle used to deregister the callback.
411              * @return  OC_STACK_OK in case of success and other value otherwise.
412              */
413             static OCStackResult deregisterDisplayPinCallback(DisplayPinCallbackHandle displayPinCallbackHandle);
414
415             /**
416              * API to get status of all the devices in current subnet. The status include endpoint
417              * information and doxm information which can be extracted during owned and unowned
418              * discovery. Along with this information, API will provide information about
419              * devices' status.
420              * Device can have following states
421              *  - ON/OFF: Device is switched on or off.
422              *
423              * @param timeout Wait time for the API.
424              * @param ownedDevList  List of owned devices.
425              * @param unownedDevList  List of unowned devices.
426              * @return ::OC_STACK_OK in case of success and other value otherwise.
427              */
428             static OCStackResult getDevInfoFromNetwork(unsigned short timeout,
429                     DeviceList_t &ownedDevList,
430                     DeviceList_t &unownedDevList);
431
432             /**
433              * API to remove device credential and ACL from all devices in subnet.
434              *
435              * @param resultCallback Callback provided by API user, callback will be called when
436              *            credential revocation is finished.
437              * @param uuid Device uuid to be revoked.
438              * @param waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device
439              *            discovery in seconds.
440              * @return  ::OC_STACK_OK in case of success and other value otherwise.
441              */
442             static OCStackResult removeDeviceWithUuid(unsigned short waitTimeForOwnedDeviceDiscovery,
443                     std::string uuid,
444                     ResultCallBack resultCallback);
445
446             /**
447              * API to save ACL which has several ACE into Acl of SVR.
448              *
449              * @param acl ACL to be saved in Acl of SVR.
450              * @return  OC_STACK_OK in case of success and other value otherwise.
451              */
452             static OCStackResult saveACL(const OicSecAcl_t* acl);
453
454             /**
455              *  api to register Callback for displaying verifNum in verification Just-Works
456              *
457              * @param displayNumCB Callback which is to be registered.
458              * @return  OC_STACK_OK in case of success and other value otherwise.
459              */
460             static OCStackResult registerDisplayNumCallback(DisplayNumCB displayNumCB);
461
462              /**
463              * API to De-register Callback for displaying verifNum in verification Just-Works
464              *
465              * @return  OC_STACK_OK in case of success and other value otherwise.
466              */
467             static OCStackResult deregisterDisplayNumCallback();
468
469             /**
470              * API to reister Callback for getting user confirmation in verification Just-Works
471              *@param userConfirmCB Callback which is to be registered.
472              * @return  OC_STACK_OK in case of success and other value otherwise.
473              */
474             static OCStackResult registerUserConfirmCallback(UserConfirmNumCB userConfirmCB);
475
476              /**
477              * API to De-register Callback for getting user confirmation in verification Just-Works
478              *
479              * @return  OC_STACK_OK in case of success and other value otherwise.
480              */
481             static OCStackResult deregisterUserConfirmCallback();
482
483              /**
484              * Set option for Mutual Verified Just-Works
485              * The default is both display PIN and get user confirmation.
486              */
487             static OCStackResult setVerifyOptionMask(VerifyOptionBitmask_t optionMask);
488
489
490             /**
491              * API to cleanup PDM in case of timeout.
492              * It will remove the PDM_DEVICE_INIT state devices from PDM.
493              *
494              * @return OC_STACK_OK in case of success and other value otherwise.
495              */
496              static OCStackResult pdmCleanupForTimeout();
497
498 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
499             /**
500              * API to save Trust certificate chain into Cred of SVR.
501              *
502              * @param[in] trustCertChain Trust certificate chain to be saved in Cred of SVR.
503              * @param[in] chainSize Size of trust certificate chain to be saved in Cred of SVR
504              * @param[in] encodingType Encoding type of trust certificate chain to be saved in Cred of SVR
505              * @param[out] credId CredId of saved trust certificate chain in Cred of SVR.
506              * @return  OC_STACK_OK in case of success and other value otherwise.
507              */
508             static OCStackResult saveTrustCertChain(uint8_t *trustCertChain, size_t chainSize,
509                                         OicEncodingType_t encodingType, uint16_t *credId);
510
511             /**
512              * API to read Trust certificate chain from SVR.
513              * Caller must free when done using the returned trust certificate
514              * @param[in] credId CredId of trust certificate chain in SVR.
515              * @param[out] trustCertChain Trust certificate chain.
516              * @param[out] chainSize Size of trust certificate chain
517              * @return  OC_STACK_OK in case of success and other value otherwise.
518              */
519             static OCStackResult readTrustCertChain(uint16_t credId, uint8_t **trustCertChain,
520                                      size_t *chainSize);
521
522             /**
523              * API to register Notifier for trustCertChain change.
524              *
525              * @param[in] TrustCertChainChangeCB trustCertChain Change will be
526              * notified asynchronously. User need to "delete[]" trustCertChain
527              * in the callback function.
528              * @return  OC_STACK_OK in case of success and other value otherwise.
529              */
530             static OCStackResult registerTrustCertChangeNotifier(CertChainCallBack);
531
532             /**
533              * API to remove Already registered Notifier.
534              *
535              *@return  OC_STACK_OK always, kept it for symmetry.
536              */
537             static OCStackResult removeTrustCertChangeNotifier();
538
539             /**
540              * Wrapper to save the seed value to generate device UUID
541              *
542              * @param[in] seed  buffer of seed value
543              * @param[in] seedSize byte length of seed
544              */
545              static OCStackResult setDeviceIdSeed(const uint8_t* seed, size_t seedSize);
546 #endif // __WITH_DTLS__ || __WITH_TLS__
547
548
549             /**
550              * This function configures SVR DB as self-ownership.
551              *
552              *@return OC_STACK_OK in case of successful configue and other value otherwise.
553              */
554             static OCStackResult configSelfOwnership();
555     };
556
557     /**
558      * This class represents a secure virtual device, which can be provisioned by the
559      * provisioning client.
560      */
561     class OCSecureResource
562     {
563         private:
564             std::weak_ptr<std::recursive_mutex> m_csdkLock;
565             OCProvisionDev_t *devPtr;   // pointer to device.
566
567         public:
568             OCSecureResource();
569             OCSecureResource(std::weak_ptr<std::recursive_mutex> csdkLock, OCProvisionDev_t *dPtr);
570
571             ~OCSecureResource();
572
573             /**
574              * API to provision credentials between two devices and ACLs for the devices who
575              * act as a server.
576              *
577              * @param cred  Type of credentials & key size to be provisioned to the device.
578              * @param acl1  ACL for device 1. If this is not required set NULL.
579              * @param device2  Second device to be provisioned.
580              * @param acl2  ACL for device 2. If this is not required set NULL.
581              * @param resultCallback Callback will be called when provisioning request receives
582              *                           a response from first resource server.
583              * @return  ::OC_STACK_OK in case of success and other value otherwise.
584              */
585             OCStackResult provisionPairwiseDevices(const Credential &cred, const OicSecAcl_t* acl1,
586                     const OCSecureResource &device2, const OicSecAcl_t* acl2,
587                     ResultCallBack resultCallback);
588
589             /**
590              * API to do ownership transfer for un-owned device.
591              *
592              * @param resultCallback Result callback function to be invoked when
593              *                           ownership transfer finished.
594              * @return ::OC_STACK_OK in case of success and other value otherwise.
595              */
596             OCStackResult doOwnershipTransfer(ResultCallBack resultCallback);
597
598             /**
599              * API to send ACL information to resource.
600              *
601              * @param acl ACL to provision.
602              * @param resultCallback Callback will be called when provisioning request
603              *                           receives a response from resource server.
604              * @return  ::OC_STACK_OK in case of success and other value otherwise.
605              */
606             OCStackResult provisionACL(const OicSecAcl_t* acl,
607                     ResultCallBack resultCallback);
608
609             /**
610              * API to provision credential to devices.
611              *
612              * @param cred Type of credentials to be provisioned to the device.
613              * @param device2 Second device' instance, representing resource to be provisioned.
614              * @param resultCallback Callback will be called when provisioning request receives
615              *                           a response from first resource server.
616              * @return  ::OC_STACK_OK in case of success and other value otherwise.
617              */
618             OCStackResult provisionCredentials(const Credential &cred,
619                     const OCSecureResource &device2,
620                     ResultCallBack resultCallback);
621
622            /**
623             * API to remove the credential & relationship between the two devices.
624             *
625             * @param device2 Second device information to be unlinked.
626             * @param resultCallback Callback provided by API user, callback will be called when
627             *            device unlink is finished.
628             * @return  ::OC_STACK_OK in case of success and other value otherwise.
629             */
630             OCStackResult unlinkDevices(const OCSecureResource &device2,
631                     ResultCallBack resultCallback);
632
633             /**
634              * API to remove device credential from all devices in subnet.
635              *
636              * @param resultCallback Callback provided by API user, callback will be called when
637              *            credential revocation is finished.
638              * @param waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device
639              *            discovery in seconds.
640              * @return  ::OC_STACK_OK in case of success and other value otherwise.
641              */
642             OCStackResult removeDevice(unsigned short waitTimeForOwnedDeviceDiscovery,
643                     ResultCallBack resultCallback);
644
645             /**
646              * API to provision DirectPairing to devices.
647              *
648              * @param pconf pointer to PCONF (Pairing Configuration).
649              * @param resultCallback Callback will be called when provisioning request receives
650              *                           a response from first resource server.
651              * @return  ::OC_STACK_OK in case of success and other value otherwise.
652              */
653             OCStackResult provisionDirectPairing(const OicSecPconf_t *pconf,
654                     ResultCallBack resultCallback);
655
656 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
657             /**
658              * API to provision cert.
659              *
660              * @param type type of cred.
661              * @param credId id of cert.
662              * @param resultCallback Callback will be called when provisioning request
663              *                           receives a response from resource server.
664              * @return  ::OC_STACK_OK in case of success and other value otherwise.
665              */
666             OCStackResult provisionTrustCertChain(OicSecCredType_t type, uint16_t credId,
667                     ResultCallBack resultCallback);
668
669 #endif // __WITH_DTLS__ or __WITH_TLS__
670
671             /**
672              * This method is used to get linked devices' IDs.
673              *
674              * @param uuidList Information about the list of linked devices uuids.
675              * @return  ::OC_STACK_OK in case of success and other value otherwise.
676              */
677             OCStackResult getLinkedDevices(UuidList_t &uuidList);
678
679             /**
680              * API to get the device ID of this resource.
681              * @return device ID.
682              */
683             std::string getDeviceID();
684
685             /**
686              * API to get the information of device for provisioning.
687              * @return OCProvisionDev_t Reference provides information of device for provisioning.
688              */
689             OCProvisionDev_t* getDevPtr()const;
690
691             /**
692              * This function returns the device's IP address.
693              * @return device address.
694              */
695             std::string getDevAddr();
696
697             /**
698              * This function returns the device's Status.
699              * @return Device status (1 = ON and 2 = OFF).
700              */
701             int getDeviceStatus();
702
703             /**
704              * This function provides the owned status of the device.
705              * @return Device owned status.
706              */
707             bool getOwnedStatus();
708
709             /**
710              * This function provides the selected ownership transfer method of the device.
711              * @return Selected ownership transfer method.
712              */
713             OicSecOxm_t getSelectedOwnershipTransferMethod();
714
715             /**
716              * API to get the proper OxM for OT.
717              *
718              * @param oxm Address to save the selected OxM.
719              *
720              * @return ::OC_STACK_OK in case of success and other value otherwise.
721              */
722             OCStackResult getOTMethod(OicSecOxm_t* oxm);
723
724 #ifdef MULTIPLE_OWNER
725             /**
726              * API to update 'doxm.oxmsel' to resource server.
727              *
728              * @param resultCallback Callback provided by API user, callback will be
729              *            called when credential revocation is finished.
730              * @param oxmSelVal Method of multiple ownership transfer (ref. oic.sec.oxm)
731              * @return  ::OC_STACK_OK in case of success and other value otherwise.
732              */
733             OCStackResult selectMOTMethod( const OicSecOxm_t oxmSelVal,
734                     ResultCallBack resultCallback);
735
736             /**
737              * API to update 'doxm.mom' to resource server.
738              *
739              * @param resultCallback Callback provided by API user, callback will be
740              *            called when credential revocation is finished.
741              * @param momType Mode of multiple ownership transfer (ref. oic.sec.mom)
742              * @return  ::OC_STACK_OK in case of success and other value otherwise.
743              */
744              OCStackResult changeMOTMode( const OicSecMomType_t momType,
745                     ResultCallBack resultCallback);
746
747             /**
748              * API to add preconfigured PIN to local SVR DB.
749              *
750              * @param preconfPIN Preconfig PIN which is used while multiple owner authentication
751              * @param preconfPINLength Byte length of preconfig PIN
752              * @return  ::OC_STACK_OK in case of success and other value otherwise.
753              */
754              OCStackResult addPreconfigPIN(const char* preconfPIN,
755                     size_t preconfPINLength);
756
757             /**
758              * API to provision preconfigured PIN.
759              *
760              * @param resultCallback Callback provided by API user, callback will be called when
761              *            credential revocation is finished.
762              * @param preconfPin Preconfig PIN which is used while multiple owner authentication
763              * @param preconfPinLength Byte length of preconfig PIN
764              * @return  ::OC_STACK_OK in case of success and other value otherwise.
765              */
766              OCStackResult provisionPreconfPin(const char * preconfPin,
767                     size_t preconfPinLength, ResultCallBack resultCallback);
768
769              /**
770              * API to do multiple ownership transfer for MOT enabled device.
771              *
772              * @param resultCallback Result callback function to be invoked when
773              *                           multiple ownership transfer finished.
774              * @return ::OC_STACK_OK in case of success and other value otherwise.
775              */
776             OCStackResult doMultipleOwnershipTransfer(ResultCallBack resultCallback);
777
778             /**
779              * API to check if the caller is a subowner of the MOT device.
780              *
781              * @param subowner  Bool indicating if the caller is a subowner.
782              *
783              * @return ::OC_STACK_OK in case of success and other values otherwise.
784              */
785             OCStackResult isSubownerOfDevice(bool* subowner);
786
787             /**
788              * API to get the proper OxM for MOT.
789              *
790              * @param oxm Address to save the selected OxM.
791              *
792              * @return ::OC_STACK_OK in case of success and other value otherwise.
793              */
794             OCStackResult getMOTMethod( OicSecOxm_t* oxm);
795
796             /**
797              * API to check whether MOT is supported.
798              *
799              * @return ::true in case of MOT supported.
800              */
801             bool isMOTSupported();
802
803             /**
804              * API to check whether MOT is enabled.
805              *
806              * @return ::true in case of MOT enabled.
807              */
808             bool isMOTEnabled();
809
810 #endif // MULTIPLE_OWNER
811
812         private:
813             /**
814              * Common callback wrapper, which will be called from OC-APIs.
815              */
816             static void callbackWrapper(void* ctx, size_t nOfRes,
817                                            OCProvisionResult_t *arr, bool hasError);
818
819             void validateSecureResource();
820     };
821
822 }
823 #endif // OC_PROVISIONINGMANAGER_CXX_H_