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