1 //****************************************************************
3 // Copyright 2015 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #ifndef OC_PROVISIONINGMANAGER_CXX_H_
22 #define OC_PROVISIONINGMANAGER_CXX_H_
26 #include "pinoxmcommon.h"
27 #include "ocprovisioningmanager.h"
29 #include "OCPlatform_impl.h"
33 class OCSecureResource;
35 typedef std::vector<std::shared_ptr<OCSecureResource>> DeviceList_t;
36 typedef std::vector<OicUuid_t> UuidList_t;
37 typedef std::vector<OCProvisionResult_t> PMResultList_t;
38 typedef std::function<void(PMResultList_t *result, int hasError)> ResultCallBack;
40 struct ProvisionContext
42 ResultCallBack callback;
43 ProvisionContext(ResultCallBack cb) : callback(cb){}
47 * This class is for credential's to be set to devices.
48 * The types supported are
50 * 1: symmetric pair-wise key
51 * 2: symmetric group key
53 * 8: signed asymmetric key (aka certificate)
58 OicSecCredType_t type;
61 Credential() = default;
62 Credential(OicSecCredType_t type, size_t size) : type(type), keySize(size)
66 * API to get credential type of device.
67 * @return credential type of device.
69 OicSecCredType_t getCredentialType() const
75 * API to get size of credential key type.
76 * @return size of credential key type.
78 size_t getCredentialKeySize() const
84 * API to set credential type of device.
85 * Device can have following credential types
86 * - symmetric pair-wise key
87 * - symmetric group key
89 * - signed asymmetric key (aka certificate)
91 * @param type credential type.
93 void setCredentialType(OicSecCredType_t type)
99 * API to set size of credential key type.
100 * @param keySize credential key size.
101 * @note can be either 128 or 256 for symmetric pair-wise key
103 void setCredentialKeySize(size_t keySize)
105 this->keySize = keySize;
113 * The API is responsible for initialization of the provisioning manager. It will load
114 * provisioning database which have owned device's list and their linked status.
116 * @param dbPath file path of the sqlite3 database.
118 * @return ::OC_STACK_OK in case of success and other value otherwise.
120 static OCStackResult provisionInit(const std::string& dbPath);
123 * API is responsible for discovery of devices in it's subnet. It will list
124 * all the device in subnet which are not yet owned.
126 * @param timeout Timeout in seconds, time until which function will listen to
127 * responses from server before returning the list of devices.
128 * @param list List of candidate devices to be provisioned.
129 * @return ::OC_STACK_OK in case of success and other value otherwise.
131 static OCStackResult discoverUnownedDevices(unsigned short timeout,
135 * API is responsible for discovery of devices in it's subnet. It will list
136 * all the device in subnet which are already owned by calling provisioning client.
138 * @param timeout Timeout in seconds, time until which function will listen to
139 * responses from server before returning the list of devices.
140 * @param list List of owned devices.
141 * @return ::OC_STACK_OK in case of success and other value otherwise.
143 static OCStackResult discoverOwnedDevices(unsigned short timeout,
147 * API for registering Ownership transfer methods for a particular transfer Type.
149 * @param oxm Ownership transfer method.
150 * @param callbackData CallbackData Methods for ownership transfer.
151 * @param inputPin Callback method to input pin for verification.
152 * @return ::OC_STACK_OK in case of success and other value otherwise.
154 static OCStackResult setOwnerTransferCallbackData(OicSecOxm_t oxm,
155 OTMCallbackData_t* callbackData, InputPinCallback inputPin);
158 * API to get status of all the devices in current subnet. The status include endpoint
159 * information and doxm information which can be extracted during owned and unowned
160 * discovery. Along with this information, API will provide information about
162 * Device can have following states
163 * - ON/OFF: Device is switched on or off.
165 * @param timeout Wait time for the API.
166 * @param ownedDevList List of owned devices.
167 * @param unownedDevList List of unowned devices.
168 * @return ::OC_STACK_OK in case of success and other value otherwise.
170 static OCStackResult getDevInfoFromNetwork(unsigned short timeout,
171 DeviceList_t &ownedDevList,
172 DeviceList_t &unownedDevList);
174 * Server API to register callback to display stack generated PIN.
176 * @param displayPin Callback Method to Display generated PIN.
177 * @return ::OC_STACK_OK in case of success and other value otherwise.
179 static OCStackResult setDisplayPinCB(GeneratePinCallback displayPin);
183 * This class represents a secure virtual device, which can be provisioned by the
184 * provisioning client.
186 class OCSecureResource
189 std::weak_ptr<std::recursive_mutex> m_csdkLock;
190 OCProvisionDev_t *devPtr; // pointer to device.
194 OCSecureResource(std::weak_ptr<std::recursive_mutex> csdkLock, OCProvisionDev_t *dPtr);
199 * API to provision credentials between two devices and ACLs for the devices who
202 * @param cred Type of credentials & key size to be provisioned to the device.
203 * @param acl1 ACL for device 1. If this is not required set NULL.
204 * @param device2 Second device to be provisioned.
205 * @param acl2 ACL for device 2. If this is not required set NULL.
206 * @param resultCallback Callback will be called when provisioning request receives
207 * a response from first resource server.
208 * @return ::OC_STACK_OK in case of success and other value otherwise.
210 OCStackResult provisionPairwiseDevices(const Credential &cred, const OicSecAcl_t* acl1,
211 const OCSecureResource &device2, const OicSecAcl_t* acl2,
212 ResultCallBack resultCallback);
215 * API to do ownership transfer for un-owned device.
217 * @param resultCallback Result callback function to be invoked when
218 * ownership transfer finished.
219 * @return ::OC_STACK_OK in case of success and other value otherwise.
221 OCStackResult doOwnershipTransfer(ResultCallBack resultCallback);
224 * API to send ACL information to resource.
226 * @param acl ACL to provision.
227 * @param resultCallback Callback will be called when provisioning request
228 * receives a response from resource server.
229 * @return ::OC_STACK_OK in case of success and other value otherwise.
231 OCStackResult provisionACL(const OicSecAcl_t* acl,
232 ResultCallBack resultCallback);
235 * API to provision credential to devices.
237 * @param cred Type of credentials to be provisioned to the device.
238 * @param device2 Second device' instance, representing resource to be provisioned.
239 * @param resultCallback Callback will be called when provisioning request receives
240 * a response from first resource server.
241 * @return ::OC_STACK_OK in case of success and other value otherwise.
243 OCStackResult provisionCredentials(const Credential &cred,
244 const OCSecureResource &device2,
245 ResultCallBack resultCallback);
248 * API to remove the credential & relationship between the two devices.
250 * @param device2 Second device information to be unlinked.
251 * @param resultCallback Callback provided by API user, callback will be called when
252 * device unlink is finished.
253 * @return ::OC_STACK_OK in case of success and other value otherwise.
255 OCStackResult unlinkDevices(const OCSecureResource &device2,
256 ResultCallBack resultCallback);
259 * API to remove device credential from all devices in subnet.
261 * @param resultCallback Callback provided by API user, callback will be called when
262 * credential revocation is finished.
263 * @param waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device
264 * discovery in seconds.
265 * @return ::OC_STACK_OK in case of success and other value otherwise.
267 OCStackResult removeDevice(unsigned short waitTimeForOwnedDeviceDiscovery,
268 ResultCallBack resultCallback);
271 * API to provision DirectPairing to devices.
273 * @param pconf pointer to PCONF (Pairing Configuration).
274 * @param resultCallback Callback will be called when provisioning request receives
275 * a response from first resource server.
276 * @return ::OC_STACK_OK in case of success and other value otherwise.
278 OCStackResult provisionDirectPairing(const OicSecPconf_t *pconf,
279 ResultCallBack resultCallback);
282 * This method is used to get linked devices' IDs.
284 * @param uuidList Information about the list of linked devices uuids.
285 * @return ::OC_STACK_OK in case of success and other value otherwise.
287 OCStackResult getLinkedDevices(UuidList_t &uuidList);
290 * API to get the device ID of this resource.
293 std::string getDeviceID();
296 * API to get the information of device for provisioning.
297 * @return @ref OCProvisionDev_t Reference provides information of device for provisioning.
299 OCProvisionDev_t* getDevPtr()const;
302 * This function returns the device's IP address.
303 * @return device address.
305 std::string getDevAddr();
308 * This function returns the device's Status.
309 * @return Device status (1 = ON and 2 = OFF).
311 int getDeviceStatus();
314 * This function provides the owned status of the device.
315 * @return Device owned status.
317 bool getOwnedStatus();
321 * Common callback wrapper, which will be called from OC-APIs.
323 static void callbackWrapper(void* ctx, int nOfRes,
324 OCProvisionResult_t *arr, bool hasError);
326 void validateSecureResource();
330 #endif // OC_PROVISIONINGMANAGER_CXX_H_