1 /* *****************************************************************
\r
3 * Copyright 2015 Samsung Electronics All Rights Reserved.
\r
7 * Licensed under the Apache License, Version 2.0 (the "License");
\r
8 * you may not use this file except in compliance with the License.
\r
9 * You may obtain a copy of the License at
\r
11 * http://www.apache.org/licenses/LICENSE-2.0
\r
13 * Unless required by applicable law or agreed to in writing, software
\r
14 * distributed under the License is distributed on an "AS IS" BASIS,
\r
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
16 * See the License for the specific language governing permissions and
\r
17 * limitations under the License.
\r
19 * *****************************************************************/
\r
21 #ifndef OCPROVISIONINGMANAGER_H_
\r
22 #define OCPROVISIONINGMANAGER_H_
\r
24 #include "octypes.h"
\r
25 #include "pmtypes.h"
\r
26 #include "ownershiptransfermanager.h"
\r
30 #endif // __cplusplus
\r
33 * The function is responsible for initializaton of the provisioning manager. It will load
\r
34 * provisioning database which have owned device's list and their linked status.
\r
35 * TODO: In addition, if there is a device(s) which has not up-to-date credentials, this function will
\r
36 * automatically try to update the deivce(s).
\r
38 * @param[in] dbPath file path of the sqlite3 db
\r
40 * @return OC_STACK_OK in case of success and other value otherwise.
\r
42 OCStackResult OCInitPM(const char* dbPath);
\r
45 * The function is responsible for discovery of owned/unowned device is specified endpoint.
\r
46 * It will return when found one or more device even though timeout is not exceeded
\r
48 * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
\r
49 * server before returning the list of devices.
\r
50 * @param[in] host address of target endpoint
\r
51 * @param[in] connType connectivity type of endpoint
\r
52 * @param[out] ppList List of device.
\r
53 * @return OTM_SUCCESS in case of success and other value otherwise.
\r
55 OCStackResult OCDiscoverSecureResource(unsigned short timeout, const char* host,
\r
56 OCConnectivityType connType, OCProvisionDev_t **ppList);
\r
59 * The function is responsible for discovery of device is current subnet. It will list
\r
60 * all the device in subnet which are not yet owned. Please call OCInit with OC_CLIENT_SERVER as
\r
63 * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
\r
64 * server before returning the list of devices.
\r
65 * @param[out] ppList List of candidate devices to be provisioned
\r
66 * @return OTM_SUCCESS in case of success and other value otherwise.
\r
68 OCStackResult OCDiscoverUnownedDevices(unsigned short waittime, OCProvisionDev_t **ppList);
\r
71 * Do ownership transfer for un-owned device.
\r
73 * @param[in] ctx Application context would be returned in result callback
\r
74 * @param[in] targetDevices List of devices to perform ownership transfer.
\r
75 * @param[in] resultCallback Result callback function to be invoked when ownership transfer finished.
\r
76 * @return OC_STACK_OK in case of success and other value otherwise.
\r
78 OCStackResult OCDoOwnershipTransfer(void* ctx,
\r
79 OCProvisionDev_t *targetDevices,
\r
80 OCProvisionResultCB resultCallback);
\r
83 * API to register for particular OxM.
\r
85 * @param[in] Ownership transfer method.
\r
86 * @param[in] Implementation of callback functions for owership transfer.
\r
87 * @return OC_STACK_OK in case of success and other value otherwise.
\r
89 OCStackResult OCSetOwnerTransferCallbackData(OicSecOxm_t oxm, OTMCallbackData_t* callbackData);
\r
92 * The function is responsible for discovery of owned device is current subnet. It will list
\r
93 * all the device in subnet which are owned by calling provisioning client.
\r
95 * @param[in] timeout Timeout in seconds, value till which function will listen to responses from
\r
96 * server before returning the list of devices.
\r
97 * @param[out] ppList List of device owned by provisioning tool.
\r
98 * @return OTM_SUCCESS in case of success and other value otherwise.
\r
100 OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList);
\r
103 * API to provision credentials between two devices and ACLs for the devices who act as a server.
\r
105 * @param[in] ctx Application context would be returned in result callback.
\r
106 * @param[in] type Type of credentials to be provisioned to the device.
\r
107 * @param[in] pDev1 Pointer to OCProvisionDev_t instance,respresenting device to be provisioned.
\r
108 * @param[in] acl ACL for device 1. If this is not required set NULL.
\r
109 * @param[in] pDev2 Pointer to OCProvisionDev_t instance,respresenting device to be provisioned.
\r
110 * @param[in] acl ACL for device 2. If this is not required set NULL.
\r
111 * @param[in] resultCallback callback provided by API user, callback will be called when
\r
112 * provisioning request recieves a response from first resource server.
\r
113 * @return OC_STACK_OK in case of success and other value otherwise.
\r
115 OCStackResult OCProvisionPairwiseDevices(void* ctx, OicSecCredType_t type, size_t keySize,
\r
116 const OCProvisionDev_t *pDev1, OicSecAcl_t *pDev1Acl,
\r
117 const OCProvisionDev_t *pDev2, OicSecAcl_t *pDev2Acl,
\r
118 OCProvisionResultCB resultCallback);
\r
121 * API to send ACL information to device.
\r
123 * @param[in] ctx Application context would be returned in result callback.
\r
124 * @param[in] selectedDeviceInfo Selected target device.
\r
125 * @param[in] acl ACL to provision.
\r
126 * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
\r
127 request recieves a response from resource server.
\r
128 * @return OC_STACK_OK in case of success and other value otherwise.
\r
130 OCStackResult OCProvisionACL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo, OicSecAcl_t *acl,
\r
131 OCProvisionResultCB resultCallback);
\r
134 * this function requests CRED information to resource.
\r
136 * @param[in] ctx Application context would be returned in result callback.
\r
137 * @param[in] selectedDeviceInfo Selected target device.
\r
138 * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
\r
139 request recieves a response from resource server.
\r
140 * @return OC_STACK_OK in case of success and other value otherwise.
\r
142 OCStackResult OCGetCredResource(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
\r
143 OCProvisionResultCB resultCallback);
\r
146 * this function requests ACL information to resource.
\r
148 * @param[in] ctx Application context would be returned in result callback.
\r
149 * @param[in] selectedDeviceInfo Selected target device.
\r
150 * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
\r
151 request recieves a response from resource server.
\r
152 * @return OC_STACK_OK in case of success and other value otherwise.
\r
154 OCStackResult OCGetACLResource(void* ctx, const OCProvisionDev_t *selectedDeviceInfo,
\r
155 OCProvisionResultCB resultCallback);
\r
158 * this function sends Direct-Pairing Configuration to a device.
\r
160 * @param[in] ctx Application context would be returned in result callback.
\r
161 * @param[in] selectedDeviceInfo Selected target device.
\r
162 * @param[in] pconf PCONF pointer.
\r
163 * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
\r
164 request recieves a response from resource server.
\r
165 * @return OC_STACK_OK in case of success and other value otherwise.
\r
167 OCStackResult OCProvisionDirectPairing(void* ctx, const OCProvisionDev_t *selectedDeviceInfo, OicSecPconf_t *pconf,
\r
168 OCProvisionResultCB resultCallback);
\r
171 * API to provision credential to devices.
\r
173 * @param[in] ctx Application context would be returned in result callback.
\r
174 * @param[in] type Type of credentials to be provisioned to the device.
\r
175 * @param[in] pDev1 Pointer to OCProvisionDev_t instance,respresenting resource to be provsioned.
\r
176 @param[in] pDev2 Pointer to OCProvisionDev_t instance,respresenting resource to be provsioned.
\r
177 * @param[in] resultCallback callback provided by API user, callback will be called when
\r
178 * provisioning request recieves a response from first resource server.
\r
179 * @return OC_STACK_OK in case of success and other value otherwise.
\r
181 OCStackResult OCProvisionCredentials(void *ctx, OicSecCredType_t type, size_t keySize,
\r
182 const OCProvisionDev_t *pDev1,
\r
183 const OCProvisionDev_t *pDev2,
\r
184 OCProvisionResultCB resultCallback);
\r
187 * Function to unlink devices.
\r
188 * This function will remove the credential & relasionship between the two devices.
\r
190 * @param[in] ctx Application context would be returned in result callback
\r
191 * @param[in] pTargetDev1 fitst device information to be unlinked.
\r
192 * @param[in] pTargetDev2 second device information to be unlinked.
\r
193 * @param[in] resultCallback callback provided by API user, callback will be called when
\r
194 * device unlink is finished.
\r
195 * @return OC_STACK_OK in case of success and other value otherwise.
\r
197 OCStackResult OCUnlinkDevices(void* ctx,
\r
198 const OCProvisionDev_t* pTargetDev1,
\r
199 const OCProvisionDev_t* pTargetDev2,
\r
200 OCProvisionResultCB resultCallback);
\r
203 * Function for device revocation
\r
204 * This function will remove credential of target device from all devices in subnet.
\r
206 * @param[in] ctx Application context would be returned in result callback
\r
207 * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
\r
208 * @param[in] pTargetDev Device information to be revoked.
\r
209 * @param[in] resultCallback callback provided by API user, callback will be called when
\r
210 * credential revocation is finished.
\r
211 * @return OC_STACK_OK in case of success and other value otherwise.
\r
212 * if OC_STACK_OK is returned, the caller of this API should wait for callback.
\r
213 * OC_STACK_CONTINUE means operation is success but no need to wait for callback.
\r
215 OCStackResult OCRemoveDevice(void* ctx,
\r
216 unsigned short waitTimeForOwnedDeviceDiscovery,
\r
217 const OCProvisionDev_t* pTargetDev,
\r
218 OCProvisionResultCB resultCallback);
\r
221 * Function to device revocation
\r
222 * This function will remove credential of target device from all devices in subnet.
\r
224 * @param[in] ctx Application context would be returned in result callback
\r
225 * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
\r
226 * @param[in] pTargetDev Device information to be revoked.
\r
227 * @param[in] resultCallback callback provided by API user, callback will be called when
\r
228 * credential revocation is finished.
\r
229 * @return OC_STACK_OK in case of success and other value otherwise.
\r
231 OCStackResult OCRemoveDeviceWithUuid(void* ctx,
\r
232 unsigned short waitTimeForOwnedDeviceDiscovery,
\r
233 const OicUuid_t* pTargetUuid,
\r
234 OCProvisionResultCB resultCallback);
\r
237 * API to get status of all the devices in current subnet. The status include endpoint information
\r
238 * and doxm information which can be extracted duing owned and unowned discovery. Along with this
\r
239 * information. The API will provide information about devices' status
\r
240 * Device can have following states
\r
241 * - ON/OFF: Device is switched on or off.
\r
243 * NOTE: Caller need to call OCDeleteDiscoveredDevices to delete memory allocated by this API for out
\r
244 * variables pOwnedDevList and pUnownedDevList.
\r
246 * @param[in] waitime Wait time for the API. The wait time will be divided by 2, and half of wait time
\r
247 * will be used for unowned discovery and remaining half for owned discovery. So the wait time should be
\r
248 * equal to or more than 2.
\r
249 * @param[out] pOwnedDevList list of owned devices.
\r
250 * @param[out] pUnownedDevList list of unowned devices.
\r
251 * @return OC_STACK_OK in case of success and other value otherwise.
\r
253 OCStackResult OCGetDevInfoFromNetwork(unsigned short waittime,
\r
254 OCProvisionDev_t** pOwnedDevList,
\r
255 OCProvisionDev_t** pUnownedDevList);
\r
257 * This method is used to get linked devices' IDs.
\r
259 * @param[in] uuidOfDevice a target device's uuid.
\r
260 * @param[out] uuidList information about the list of linked devices' uuids.
\r
261 * @param[out] numOfDevices total number of linked devices.
\r
262 * @return OC_STACK_OK in case of success and other value otherwise.
\r
264 OCStackResult OCGetLinkedStatus(const OicUuid_t* uuidOfDevice,
\r
265 OCUuidList_t** uuidList,
\r
266 size_t* numOfDevices);
\r
269 * API to delete memory allocated to linked list created by OCDiscover_XXX_Devices API.
\r
271 * @param[in] pList Pointer to OCProvisionDev_t which should be deleted.
\r
273 void OCDeleteDiscoveredDevices(OCProvisionDev_t *pList);
\r
276 * API to delete memory allocated to OicUuid_t list.
\r
278 * @param[in] pList Pointer to OicUuid_t list which should be deleted.
\r
280 void OCDeleteUuidList(OCUuidList_t* pList);
\r
283 * This function deletes ACL data.
\r
285 * @param pAcl Pointer to OicSecAcl_t structure.
\r
287 void OCDeleteACLList(OicSecAcl_t* pAcl);
\r
290 * This function deletes PDACL data.
\r
292 * @param pPdAcl Pointer to OicSecPdAcl_t structure.
\r
294 void OCDeletePdAclList(OicSecPdAcl_t* pPdAcl);
\r
296 #if defined(__WITH_X509__) || defined(__WITH_TLS__)
\r
298 * this function sends CRL information to resource.
\r
300 * @param[in] ctx Application context would be returned in result callback.
\r
301 * @param[in] selectedDeviceInfo Selected target device.
\r
302 * @param[in] crl CRL to provision.
\r
303 * @param[in] resultCallback callback provided by API user, callback will be called when provisioning
\r
304 request recieves a response from resource server.
\r
305 * @return OC_STACK_OK in case of success and other value otherwise.
\r
307 OCStackResult OCProvisionCRL(void* ctx, const OCProvisionDev_t *selectedDeviceInfo, OicSecCrl_t *crl,
\r
308 OCProvisionResultCB resultCallback);
\r
311 * function to provision Trust certificate chain to devices.
\r
313 * @param[in] ctx Application context would be returned in result callback.
\r
314 * @param[in] type Type of credentials to be provisioned to the device.
\r
315 * @param[in] credId CredId of trust certificate chain to be provisioned to the device.
\r
316 * @param[in] selectedDeviceInfo Pointer to OCProvisionDev_t instance,respresenting resource to be provsioned.
\r
317 * @param[in] resultCallback callback provided by API user, callback will be called when
\r
318 * provisioning request recieves a response from first resource server.
\r
319 * @return OC_STACK_OK in case of success and other value otherwise.
\r
321 OCStackResult OCProvisionTrustCertChain(void *ctx, OicSecCredType_t type, uint16_t credId,
\r
322 const OCProvisionDev_t *selectedDeviceInfo,
\r
323 OCProvisionResultCB resultCallback);
\r
325 * function to save Trust certificate chain into Cred of SVR.
\r
327 * @param[in] trustCertChain Trust certificate chain to be saved in Cred of SVR.
\r
328 * @param[in] chainSize Size of trust certificate chain to be saved in Cred of SVR
\r
329 * @param[in] encodingType Encoding type of trust certificate chain to be saved in Cred of SVR
\r
330 * @param[out] credId CredId of saved trust certificate chain in Cred of SVR.
\r
331 * @return OC_STACK_OK in case of success and other value otherwise.
\r
333 OCStackResult OCSaveTrustCertChain(uint8_t *trustCertChain, size_t chainSize,
\r
334 OicEncodingType_t encodingType, uint16_t *credId);
\r
336 #endif // __WITH_X509__ || __WITH_TLS__
\r
341 #endif // __cplusplus
\r
343 #endif /* OCPROVISIONINGMANAGER_H_ */
\r