1 /*
2 * SPDX-FileCopyrightText: 2017-2024 Espressif Systems (Shanghai) CO LTD
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <stdint.h>
8 #include <string.h>
9
10 #include "esp_err.h"
11
12 #include "btc_ble_mesh_prov.h"
13 #include "esp_ble_mesh_provisioning_api.h"
14
15 #define MAX_PROV_LINK_IDX (CONFIG_BLE_MESH_PBA_SAME_TIME + CONFIG_BLE_MESH_PBG_SAME_TIME)
16 #define MAX_OOB_INPUT_NUM 0x5F5E0FF /* Decimal: 99999999 */
17
esp_ble_mesh_register_prov_callback(esp_ble_mesh_prov_cb_t callback)18 esp_err_t esp_ble_mesh_register_prov_callback(esp_ble_mesh_prov_cb_t callback)
19 {
20 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
21
22 return (btc_profile_cb_set(BTC_PID_PROV, callback) == 0 ? ESP_OK : ESP_FAIL);
23 }
24
esp_ble_mesh_node_is_provisioned(void)25 bool esp_ble_mesh_node_is_provisioned(void)
26 {
27 return bt_mesh_is_provisioned();
28 }
29
prov_bearers_valid(esp_ble_mesh_prov_bearer_t bearers)30 static bool prov_bearers_valid(esp_ble_mesh_prov_bearer_t bearers)
31 {
32 if ((!(bearers & (ESP_BLE_MESH_PROV_ADV | ESP_BLE_MESH_PROV_GATT))) ||
33 (IS_ENABLED(CONFIG_BLE_MESH_PB_ADV) &&
34 !IS_ENABLED(CONFIG_BLE_MESH_PB_GATT) &&
35 !(bearers & ESP_BLE_MESH_PROV_ADV)) ||
36 (!IS_ENABLED(CONFIG_BLE_MESH_PB_ADV) &&
37 IS_ENABLED(CONFIG_BLE_MESH_PB_GATT) &&
38 !(bearers & ESP_BLE_MESH_PROV_GATT))) {
39 return false;
40 }
41 return true;
42 }
43
esp_ble_mesh_node_prov_enable(esp_ble_mesh_prov_bearer_t bearers)44 esp_err_t esp_ble_mesh_node_prov_enable(esp_ble_mesh_prov_bearer_t bearers)
45 {
46 btc_ble_mesh_prov_args_t arg = {0};
47 btc_msg_t msg = {0};
48
49 if (prov_bearers_valid(bearers) == false) {
50 return ESP_ERR_INVALID_ARG;
51 }
52
53 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
54
55 msg.sig = BTC_SIG_API_CALL;
56 msg.pid = BTC_PID_PROV;
57 msg.act = BTC_BLE_MESH_ACT_PROV_ENABLE;
58 arg.node_prov_enable.bearers = bearers;
59
60 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
61 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
62 }
63
esp_ble_mesh_node_prov_disable(esp_ble_mesh_prov_bearer_t bearers)64 esp_err_t esp_ble_mesh_node_prov_disable(esp_ble_mesh_prov_bearer_t bearers)
65 {
66 btc_ble_mesh_prov_args_t arg = {0};
67 btc_msg_t msg = {0};
68
69 if (prov_bearers_valid(bearers) == false) {
70 return ESP_ERR_INVALID_ARG;
71 }
72
73 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
74
75 msg.sig = BTC_SIG_API_CALL;
76 msg.pid = BTC_PID_PROV;
77 msg.act = BTC_BLE_MESH_ACT_PROV_DISABLE;
78 arg.node_prov_disable.bearers = bearers;
79
80 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
81 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
82 }
83
esp_ble_mesh_node_set_oob_pub_key(uint8_t pub_key_x[32],uint8_t pub_key_y[32],uint8_t private_key[32])84 esp_err_t esp_ble_mesh_node_set_oob_pub_key(uint8_t pub_key_x[32], uint8_t pub_key_y[32],
85 uint8_t private_key[32])
86 {
87 btc_ble_mesh_prov_args_t arg = {0};
88 btc_msg_t msg = {0};
89
90 if (!pub_key_x || !pub_key_y || !private_key) {
91 return ESP_ERR_INVALID_ARG;
92 }
93
94 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
95
96 msg.sig = BTC_SIG_API_CALL;
97 msg.pid = BTC_PID_PROV;
98 msg.act = BTC_BLE_MESH_ACT_SET_OOB_PUB_KEY;
99
100 memcpy(arg.set_oob_pub_key.pub_key_x, pub_key_x, 32);
101 memcpy(arg.set_oob_pub_key.pub_key_y, pub_key_y, 32);
102 memcpy(arg.set_oob_pub_key.private_key, private_key, 32);
103
104 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
105 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
106 }
107
esp_ble_mesh_node_input_number(uint32_t number)108 esp_err_t esp_ble_mesh_node_input_number(uint32_t number)
109 {
110 btc_ble_mesh_prov_args_t arg = {0};
111 btc_msg_t msg = {0};
112
113 if (number > MAX_OOB_INPUT_NUM) {
114 return ESP_ERR_INVALID_ARG;
115 }
116
117 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
118
119 msg.sig = BTC_SIG_API_CALL;
120 msg.pid = BTC_PID_PROV;
121 msg.act = BTC_BLE_MESH_ACT_INPUT_NUMBER;
122 arg.input_number.number = number;
123
124 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
125 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
126 }
127
esp_ble_mesh_node_input_string(const char * string)128 esp_err_t esp_ble_mesh_node_input_string(const char *string)
129 {
130 btc_ble_mesh_prov_args_t arg = {0};
131 btc_msg_t msg = {0};
132
133 if (!string || strlen(string) > ESP_BLE_MESH_PROV_INPUT_OOB_MAX_LEN) {
134 return ESP_ERR_INVALID_ARG;
135 }
136
137 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
138
139 msg.sig = BTC_SIG_API_CALL;
140 msg.pid = BTC_PID_PROV;
141 msg.act = BTC_BLE_MESH_ACT_INPUT_STRING;
142
143 arg.input_string.string[sizeof(arg.input_string.string) - 1] = 0;
144 strncpy(arg.input_string.string, string, sizeof(arg.input_string.string) - 1);
145
146 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
147 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
148 }
149
esp_ble_mesh_set_unprovisioned_device_name(const char * name)150 esp_err_t esp_ble_mesh_set_unprovisioned_device_name(const char *name)
151 {
152 btc_ble_mesh_prov_args_t arg = {0};
153 btc_msg_t msg = {0};
154
155 if (!name || strlen(name) > ESP_BLE_MESH_DEVICE_NAME_MAX_LEN) {
156 return ESP_ERR_INVALID_ARG;
157 }
158
159 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
160
161 msg.sig = BTC_SIG_API_CALL;
162 msg.pid = BTC_PID_PROV;
163 msg.act = BTC_BLE_MESH_ACT_SET_DEVICE_NAME;
164
165 arg.set_device_name.name[sizeof(arg.set_device_name.name) - 1] = 0;
166 strncpy(arg.set_device_name.name, name, sizeof(arg.set_device_name.name) - 1);
167
168 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
169 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
170 }
171
172 #if (CONFIG_BLE_MESH_PROVISIONER)
esp_ble_mesh_provisioner_read_oob_pub_key(uint8_t link_idx,uint8_t pub_key_x[32],uint8_t pub_key_y[32])173 esp_err_t esp_ble_mesh_provisioner_read_oob_pub_key(uint8_t link_idx, uint8_t pub_key_x[32],
174 uint8_t pub_key_y[32])
175 {
176 btc_ble_mesh_prov_args_t arg = {0};
177 btc_msg_t msg = {0};
178
179 if (!pub_key_x || !pub_key_y || link_idx >= MAX_PROV_LINK_IDX) {
180 return ESP_ERR_INVALID_ARG;
181 }
182
183 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
184
185 msg.sig = BTC_SIG_API_CALL;
186 msg.pid = BTC_PID_PROV;
187 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_READ_OOB_PUB_KEY;
188
189 arg.provisioner_read_oob_pub_key.link_idx = link_idx;
190 memcpy(arg.provisioner_read_oob_pub_key.pub_key_x, pub_key_x, 32);
191 memcpy(arg.provisioner_read_oob_pub_key.pub_key_y, pub_key_y, 32);
192
193 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
194 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
195 }
196
esp_ble_mesh_provisioner_input_string(const char * string,uint8_t link_idx)197 esp_err_t esp_ble_mesh_provisioner_input_string(const char *string, uint8_t link_idx)
198 {
199 btc_ble_mesh_prov_args_t arg = {0};
200 btc_msg_t msg = {0};
201
202 if (!string || strlen(string) > ESP_BLE_MESH_PROV_OUTPUT_OOB_MAX_LEN ||
203 link_idx >= MAX_PROV_LINK_IDX) {
204 return ESP_ERR_INVALID_ARG;
205 }
206
207 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
208
209 msg.sig = BTC_SIG_API_CALL;
210 msg.pid = BTC_PID_PROV;
211 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_INPUT_STR;
212
213 arg.provisioner_input_str.string[sizeof(arg.provisioner_input_str.string) - 1] = 0;
214 strncpy(arg.provisioner_input_str.string, string, sizeof(arg.provisioner_input_str.string) - 1);
215 arg.provisioner_input_str.link_idx = link_idx;
216
217 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
218 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
219 }
220
esp_ble_mesh_provisioner_input_number(uint32_t number,uint8_t link_idx)221 esp_err_t esp_ble_mesh_provisioner_input_number(uint32_t number, uint8_t link_idx)
222 {
223 btc_ble_mesh_prov_args_t arg = {0};
224 btc_msg_t msg = {0};
225
226 if (number > MAX_OOB_INPUT_NUM || link_idx >= MAX_PROV_LINK_IDX) {
227 return ESP_ERR_INVALID_ARG;
228 }
229
230 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
231
232 msg.sig = BTC_SIG_API_CALL;
233 msg.pid = BTC_PID_PROV;
234 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_INPUT_NUM;
235
236 arg.provisioner_input_num.number = number;
237 arg.provisioner_input_num.link_idx = link_idx;
238
239 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
240 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
241 }
242
esp_ble_mesh_provisioner_prov_enable(esp_ble_mesh_prov_bearer_t bearers)243 esp_err_t esp_ble_mesh_provisioner_prov_enable(esp_ble_mesh_prov_bearer_t bearers)
244 {
245 btc_ble_mesh_prov_args_t arg = {0};
246 btc_msg_t msg = {0};
247
248 if (prov_bearers_valid(bearers) == false) {
249 return ESP_ERR_INVALID_ARG;
250 }
251
252 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
253
254 msg.sig = BTC_SIG_API_CALL;
255 msg.pid = BTC_PID_PROV;
256 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_ENABLE;
257
258 arg.provisioner_enable.bearers = bearers;
259
260 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
261 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
262 }
263
esp_ble_mesh_provisioner_prov_disable(esp_ble_mesh_prov_bearer_t bearers)264 esp_err_t esp_ble_mesh_provisioner_prov_disable(esp_ble_mesh_prov_bearer_t bearers)
265 {
266 btc_ble_mesh_prov_args_t arg = {0};
267 btc_msg_t msg = {0};
268
269 if (prov_bearers_valid(bearers) == false) {
270 return ESP_ERR_INVALID_ARG;
271 }
272
273 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
274
275 msg.sig = BTC_SIG_API_CALL;
276 msg.pid = BTC_PID_PROV;
277 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_DISABLE;
278
279 arg.provisioner_disable.bearers = bearers;
280
281 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
282 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
283 }
284
esp_ble_mesh_provisioner_add_unprov_dev(esp_ble_mesh_unprov_dev_add_t * add_dev,esp_ble_mesh_dev_add_flag_t flags)285 esp_err_t esp_ble_mesh_provisioner_add_unprov_dev(esp_ble_mesh_unprov_dev_add_t *add_dev,
286 esp_ble_mesh_dev_add_flag_t flags)
287 {
288 btc_ble_mesh_prov_args_t arg = {0};
289 btc_msg_t msg = {0};
290
291 if (add_dev == NULL) {
292 return ESP_ERR_INVALID_ARG;
293 }
294
295 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
296
297 msg.sig = BTC_SIG_API_CALL;
298 msg.pid = BTC_PID_PROV;
299 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_DEV_ADD;
300
301 arg.provisioner_dev_add.add_dev.addr_type = add_dev->addr_type;
302 arg.provisioner_dev_add.add_dev.oob_info = add_dev->oob_info;
303 arg.provisioner_dev_add.add_dev.bearer = add_dev->bearer;
304 memcpy(arg.provisioner_dev_add.add_dev.addr, add_dev->addr, sizeof(esp_ble_mesh_bd_addr_t));
305 memcpy(arg.provisioner_dev_add.add_dev.uuid, add_dev->uuid, 16);
306 arg.provisioner_dev_add.flags = flags;
307 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
308 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
309 }
310
esp_ble_mesh_provisioner_prov_device_with_addr(const uint8_t uuid[16],esp_ble_mesh_bd_addr_t addr,esp_ble_mesh_addr_type_t addr_type,esp_ble_mesh_prov_bearer_t bearer,uint16_t oob_info,uint16_t unicast_addr)311 esp_err_t esp_ble_mesh_provisioner_prov_device_with_addr(const uint8_t uuid[16],
312 esp_ble_mesh_bd_addr_t addr,
313 esp_ble_mesh_addr_type_t addr_type,
314 esp_ble_mesh_prov_bearer_t bearer,
315 uint16_t oob_info, uint16_t unicast_addr)
316 {
317 btc_ble_mesh_prov_args_t arg = {0};
318 btc_msg_t msg = {0};
319
320 if (uuid == NULL || (bearer == ESP_BLE_MESH_PROV_GATT && (addr == NULL ||
321 addr_type > ESP_BLE_MESH_ADDR_TYPE_RANDOM)) ||
322 (bearer != ESP_BLE_MESH_PROV_ADV && bearer != ESP_BLE_MESH_PROV_GATT) ||
323 !ESP_BLE_MESH_ADDR_IS_UNICAST(unicast_addr)) {
324 return ESP_ERR_INVALID_ARG;
325 }
326
327 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
328
329 msg.sig = BTC_SIG_API_CALL;
330 msg.pid = BTC_PID_PROV;
331 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_PROV_DEV_WITH_ADDR;
332
333 memcpy(arg.provisioner_prov_dev_with_addr.uuid, uuid, 16);
334 if (addr) {
335 memcpy(arg.provisioner_prov_dev_with_addr.addr, addr, BD_ADDR_LEN);
336 arg.provisioner_prov_dev_with_addr.addr_type = addr_type;
337 }
338 arg.provisioner_prov_dev_with_addr.bearer = bearer;
339 arg.provisioner_prov_dev_with_addr.oob_info = oob_info;
340 arg.provisioner_prov_dev_with_addr.unicast_addr = unicast_addr;
341 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
342 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
343 }
344
esp_ble_mesh_provisioner_delete_dev(esp_ble_mesh_device_delete_t * del_dev)345 esp_err_t esp_ble_mesh_provisioner_delete_dev(esp_ble_mesh_device_delete_t *del_dev)
346 {
347 uint8_t val = DEL_DEV_ADDR_FLAG | DEL_DEV_UUID_FLAG;
348 btc_ble_mesh_prov_args_t arg = {0};
349 btc_msg_t msg = {0};
350
351 if (del_dev == NULL || (__builtin_popcount(del_dev->flag & val) != 1)) {
352 return ESP_ERR_INVALID_ARG;
353 }
354
355 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
356
357 msg.sig = BTC_SIG_API_CALL;
358 msg.pid = BTC_PID_PROV;
359 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_DEV_DEL;
360
361 arg.provisioner_dev_del.del_dev.flag = del_dev->flag;
362 if (del_dev->flag & DEL_DEV_ADDR_FLAG) {
363 arg.provisioner_dev_del.del_dev.addr_type = del_dev->addr_type;
364 memcpy(arg.provisioner_dev_del.del_dev.addr, del_dev->addr, sizeof(esp_ble_mesh_bd_addr_t));
365 } else if (del_dev->flag & DEL_DEV_UUID_FLAG) {
366 memcpy(arg.provisioner_dev_del.del_dev.uuid, del_dev->uuid, 16);
367 }
368 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
369 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
370 }
371
esp_ble_mesh_provisioner_set_dev_uuid_match(const uint8_t * match_val,uint8_t match_len,uint8_t offset,bool prov_after_match)372 esp_err_t esp_ble_mesh_provisioner_set_dev_uuid_match(const uint8_t *match_val, uint8_t match_len,
373 uint8_t offset, bool prov_after_match)
374 {
375 btc_ble_mesh_prov_args_t arg = {0};
376 btc_msg_t msg = {0};
377
378 if (match_len + offset > ESP_BLE_MESH_OCTET16_LEN) {
379 return ESP_ERR_INVALID_ARG;
380 }
381
382 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
383
384 msg.sig = BTC_SIG_API_CALL;
385 msg.pid = BTC_PID_PROV;
386 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_SET_DEV_UUID_MATCH;
387
388 if (match_len && match_val) {
389 memcpy(arg.set_dev_uuid_match.match_val, match_val, match_len);
390 }
391 arg.set_dev_uuid_match.match_len = match_len;
392 arg.set_dev_uuid_match.offset = offset;
393 arg.set_dev_uuid_match.prov_after_match = prov_after_match;
394 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
395 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
396 }
397
esp_ble_mesh_provisioner_set_prov_data_info(esp_ble_mesh_prov_data_info_t * prov_data_info)398 esp_err_t esp_ble_mesh_provisioner_set_prov_data_info(esp_ble_mesh_prov_data_info_t *prov_data_info)
399 {
400 uint8_t val = PROV_DATA_NET_IDX_FLAG | PROV_DATA_FLAGS_FLAG | PROV_DATA_IV_INDEX_FLAG;
401 btc_ble_mesh_prov_args_t arg = {0};
402 btc_msg_t msg = {0};
403
404 if (prov_data_info == NULL || (__builtin_popcount(prov_data_info->flag & val) != 1)) {
405 return ESP_ERR_INVALID_ARG;
406 }
407
408 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
409
410 msg.sig = BTC_SIG_API_CALL;
411 msg.pid = BTC_PID_PROV;
412 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_SET_PROV_DATA_INFO;
413
414 arg.set_prov_data_info.prov_data.flag = prov_data_info->flag;
415 if (prov_data_info->flag & PROV_DATA_NET_IDX_FLAG) {
416 arg.set_prov_data_info.prov_data.net_idx = prov_data_info->net_idx;
417 } else if (prov_data_info->flag & PROV_DATA_FLAGS_FLAG) {
418 arg.set_prov_data_info.prov_data.flags = prov_data_info->flags;
419 } else if (prov_data_info->flag & PROV_DATA_IV_INDEX_FLAG) {
420 arg.set_prov_data_info.prov_data.iv_index = prov_data_info->iv_index;
421 }
422 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
423 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
424 }
425
esp_ble_mesh_provisioner_set_static_oob_value(const uint8_t * value,uint8_t length)426 esp_err_t esp_ble_mesh_provisioner_set_static_oob_value(const uint8_t *value, uint8_t length)
427 {
428 btc_ble_mesh_prov_args_t arg = {0};
429 btc_msg_t msg = {0};
430
431 if (value == NULL || length == 0 || length > 16) {
432 return ESP_ERR_INVALID_ARG;
433 }
434
435 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
436
437 msg.sig = BTC_SIG_API_CALL;
438 msg.pid = BTC_PID_PROV;
439 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_SET_STATIC_OOB_VAL;
440
441 arg.set_static_oob_val.length = length;
442 memcpy(arg.set_static_oob_val.value, value, length);
443 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
444 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
445 }
446
esp_ble_mesh_provisioner_set_primary_elem_addr(uint16_t addr)447 esp_err_t esp_ble_mesh_provisioner_set_primary_elem_addr(uint16_t addr)
448 {
449 btc_ble_mesh_prov_args_t arg = {0};
450 btc_msg_t msg = {0};
451
452 if (!ESP_BLE_MESH_ADDR_IS_UNICAST(addr)) {
453 return ESP_ERR_INVALID_ARG;
454 }
455
456 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
457
458 msg.sig = BTC_SIG_API_CALL;
459 msg.pid = BTC_PID_PROV;
460 msg.act = BTC_BLE_MESH_ACT_PROVISIONER_SET_PRIMARY_ELEM_ADDR;
461
462 arg.set_primary_elem_addr.addr = addr;
463 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
464 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
465 }
466
467 #endif /* CONFIG_BLE_MESH_PROVISIONER */
468
469 /* The following APIs are for fast provisioning */
470
471 #if (CONFIG_BLE_MESH_FAST_PROV)
472
esp_ble_mesh_set_fast_prov_info(esp_ble_mesh_fast_prov_info_t * fast_prov_info)473 esp_err_t esp_ble_mesh_set_fast_prov_info(esp_ble_mesh_fast_prov_info_t *fast_prov_info)
474 {
475 btc_ble_mesh_prov_args_t arg = {0};
476 btc_msg_t msg = {0};
477
478 if (fast_prov_info == NULL || (fast_prov_info->offset +
479 fast_prov_info->match_len > ESP_BLE_MESH_OCTET16_LEN)) {
480 return ESP_ERR_INVALID_ARG;
481 }
482
483 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
484
485 msg.sig = BTC_SIG_API_CALL;
486 msg.pid = BTC_PID_PROV;
487 msg.act = BTC_BLE_MESH_ACT_SET_FAST_PROV_INFO;
488
489 arg.set_fast_prov_info.unicast_min = fast_prov_info->unicast_min;
490 arg.set_fast_prov_info.unicast_max = fast_prov_info->unicast_max;
491 arg.set_fast_prov_info.net_idx = fast_prov_info->net_idx;
492 arg.set_fast_prov_info.flags = fast_prov_info->flags;
493 arg.set_fast_prov_info.iv_index = fast_prov_info->iv_index;
494 arg.set_fast_prov_info.offset = fast_prov_info->offset;
495 arg.set_fast_prov_info.match_len = fast_prov_info->match_len;
496 if (fast_prov_info->match_len) {
497 memcpy(arg.set_fast_prov_info.match_val, fast_prov_info->match_val, fast_prov_info->match_len);
498 }
499 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
500 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
501 }
502
esp_ble_mesh_set_fast_prov_action(esp_ble_mesh_fast_prov_action_t action)503 esp_err_t esp_ble_mesh_set_fast_prov_action(esp_ble_mesh_fast_prov_action_t action)
504 {
505 btc_ble_mesh_prov_args_t arg = {0};
506 btc_msg_t msg = {0};
507
508 if (action >= FAST_PROV_ACT_MAX) {
509 return ESP_ERR_INVALID_ARG;
510 }
511
512 ESP_BLE_HOST_STATUS_CHECK(ESP_BLE_HOST_STATUS_ENABLED);
513
514 msg.sig = BTC_SIG_API_CALL;
515 msg.pid = BTC_PID_PROV;
516 msg.act = BTC_BLE_MESH_ACT_SET_FAST_PROV_ACTION;
517
518 arg.set_fast_prov_action.action = action;
519 return (btc_transfer_context(&msg, &arg, sizeof(btc_ble_mesh_prov_args_t), NULL, NULL)
520 == BT_STATUS_SUCCESS ? ESP_OK : ESP_FAIL);
521 }
522
523 #endif /* CONFIG_BLE_MESH_FAST_PROV */
524
