bt-api/bt-mesh.c

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * @author: Anupam Roy  <anupam.r@samsung.com>
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include "bluetooth-api.h"
  21 #include "bt-internal-types.h"
  22
  23 #include "bt-common.h"
  24 #include "bt-request-sender.h"
  25 #include "bt-event-handler.h"
  26
  27 #include "bluetooth-mesh-api.h"
  28
  29 #define BLUETOOTH_MESH_NETWORK_NAME_STRING_MAX 100
  30 #define BLUETOOTH_MESH_TOKEN_STRING_MAX 100
  31
  32 BT_EXPORT_API int bluetooth_mesh_init(mesh_cb_func_ptr cb,
  33                         void *user_data)
  34 {
  35         int ret;
  36
  37         if (cb == NULL) {
  38                 BT_ERR("callback is NULL");
  39                 return BLUETOOTH_ERROR_INVALID_PARAM;
  40         }
  41         ret = _bt_init_event_handler();
  42
  43         if (ret != BLUETOOTH_ERROR_NONE &&
  44                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  45                 BT_ERR("Fail to init the event handler");
  46                 return ret;
  47         }
  48
  49         _bt_set_user_data(BT_MESH, (void *)cb, user_data);
  50
  51         /* Register All events */
  52         ret = _bt_register_event(BT_MESH_EVENT, (void *)cb, user_data);
  53         if (ret != BLUETOOTH_ERROR_NONE &&
  54                         ret != BLUETOOTH_ERROR_ALREADY_INITIALIZED) {
  55                 _bt_deinit_event_handler();
  56                 return ret;
  57         }
  58
  59         BT_INFO("Mesh: Event registsred");
  60         return BLUETOOTH_ERROR_NONE;
  61 }
  62
  63 BT_EXPORT_API int bluetooth_mesh_deinit(void)
  64 {
  65         _bt_unregister_event(BT_MESH_EVENT);
  66         _bt_set_user_data(BT_MESH, NULL, NULL);
  67
  68         return BLUETOOTH_ERROR_NONE;
  69 }
  70
  71 BT_EXPORT_API int bluetooth_mesh_network_create(
  72         const char *net_name, bluetooth_mesh_node_t *node,
  73                 uint16_t total_models, bluetooth_mesh_model_t **models,
  74                         bluetooth_mesh_network_t *network)
  75 {
  76         int result;
  77         char network_name[BLUETOOTH_MESH_NETWORK_NAME_STRING_MAX+1];
  78
  79         BT_CHECK_PARAMETER(net_name, return);
  80         BT_CHECK_PARAMETER(node, return);
  81         BT_CHECK_PARAMETER(models, return);
  82
  83         BT_INIT_PARAMS();
  84         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  85
  86         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_t));
  87
  88         g_strlcpy(network_name, net_name, sizeof(network_name));
  89         g_array_append_vals(in_param2, network_name,
  90                         BLUETOOTH_MESH_NETWORK_NAME_STRING_MAX);
  91
  92         for(int i = 0; i < total_models; i++)
  93                 g_array_append_vals(in_param3, models[i],
  94                                 sizeof(bluetooth_mesh_model_t));
  95
  96         result = _bt_send_request(BT_BLUEZ_SERVICE,
  97                         BT_MESH_NETWORK_CREATE,
  98                                 in_param1, in_param2, in_param3,
  99                                         in_param4, &out_param);
 100
 101         if (result == BLUETOOTH_ERROR_NONE) {
 102                 *network = g_array_index(out_param,
 103                                 bluetooth_mesh_network_t, 0);
 104         }
 105
 106         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 107
 108         return result;
 109 }
 110
 111 BT_EXPORT_API int bluetooth_mesh_network_load(
 112                 const char *token,
 113                         bluetooth_mesh_network_t *network)
 114 {
 115         int result;
 116         char token_string[BLUETOOTH_MESH_TOKEN_STRING_MAX + 1];
 117
 118         BT_CHECK_PARAMETER(token, return);
 119         BT_CHECK_PARAMETER(network, return);
 120
 121         BT_INIT_PARAMS();
 122         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 123
 124         g_strlcpy(token_string, token, sizeof(token_string));
 125         g_array_append_vals(in_param1, token_string, BLUETOOTH_MESH_TOKEN_STRING_MAX);
 126
 127         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_LOAD,
 128                         in_param1, in_param2, in_param3, in_param4, &out_param);
 129
 130         if (result == BLUETOOTH_ERROR_NONE) {
 131                 *network = g_array_index(out_param,
 132                                 bluetooth_mesh_network_t, 0);
 133         }
 134
 135         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 136
 137         return result;
 138 }
 139
 140 BT_EXPORT_API int bluetooth_mesh_network_scan(
 141                         bluetooth_mesh_network_t *network,
 142                                 bluetooth_mesh_scan_param_t *scan_param)
 143 {
 144         int result;
 145
 146         BT_CHECK_PARAMETER(network, return);
 147         BT_CHECK_PARAMETER(scan_param, return);
 148
 149         BT_INIT_PARAMS();
 150         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 151
 152         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 153
 154         g_array_append_vals(in_param2, scan_param, sizeof(bluetooth_mesh_scan_param_t));
 155
 156         BT_INFO("Mesh:Start Scan, time [%u]", scan_param->scan_time);
 157         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_SCAN,
 158                         in_param1, in_param2, in_param3, in_param4, &out_param);
 159         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 160
 161         return result;
 162 }
 163
 164 BT_EXPORT_API int bluetooth_mesh_network_cancel_scan(
 165                 bluetooth_mesh_network_t *network)
 166 {
 167         int result;
 168
 169         BT_CHECK_PARAMETER(network, return);
 170
 171         BT_INIT_PARAMS();
 172         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 173
 174         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 175
 176         BT_INFO("Mesh: Cancel Scan");
 177         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_CANCEL_SCAN,
 178                         in_param1, in_param2, in_param3, in_param4, &out_param);
 179         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 180
 181         return result;
 182 }
 183
 184 BT_EXPORT_API int bluetooth_mesh_network_set_capabilities(
 185         bluetooth_mesh_network_t *network,
 186                 bluetooth_mesh_provisioner_caps_t *caps)
 187 {
 188         int result;
 189
 190         BT_CHECK_PARAMETER(network, return);
 191         BT_CHECK_PARAMETER(caps, return);
 192
 193         BT_INIT_PARAMS();
 194         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 195
 196         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 197
 198         g_array_append_vals(in_param2, caps, sizeof(bluetooth_mesh_provisioner_caps_t));
 199
 200         BT_INFO("Mesh: Set Provisioner capabilities");
 201         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_SET_CAPABILITIES,
 202                         in_param1, in_param2, in_param3, in_param4, &out_param);
 203         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 204
 205         return result;
 206 }
 207
 208 BT_EXPORT_API int bluetooth_mesh_network_provision_device(
 209                 bluetooth_mesh_provisioning_request_t *req)
 210 {
 211         int result;
 212         bt_user_info_t *user_info;
 213
 214         BT_CHECK_PARAMETER(req, return);
 215
 216         user_info = _bt_get_user_data(BT_MESH);
 217         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 218
 219         BT_INIT_PARAMS();
 220         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 221
 222         g_array_append_vals(in_param1, req,
 223                         sizeof(bluetooth_mesh_provisioning_request_t));
 224
 225         BT_INFO("Mesh: Set Provision Device");
 226         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
 227                         BT_MESH_NETWORK_PROVISION_DEVICE,
 228                         in_param1, in_param2, in_param3, in_param4,
 229                         user_info->cb, user_info->user_data);
 230
 231         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 232
 233         return result;
 234 }
 235
 236 BT_EXPORT_API int bluetooth_mesh_authentication_reply(int auth_type,
 237                 const char *auth_val, gboolean reply)
 238 {
 239         int result;
 240
 241         char auth_string[BLUETOOTH_MESH_AUTH_VALUE_LENGTH_MAX];
 242
 243         BT_CHECK_PARAMETER(auth_val, return);
 244
 245         BT_INIT_PARAMS();
 246         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 247
 248         g_strlcpy(auth_string, auth_val,
 249                         sizeof(auth_string));
 250         g_array_append_vals(in_param1,
 251                         &auth_type, sizeof(int));
 252         g_array_append_vals(in_param2, auth_string,
 253                         BLUETOOTH_MESH_AUTH_VALUE_LENGTH_MAX);
 254         g_array_append_vals(in_param3, &reply, sizeof(gboolean));
 255
 256         BT_INFO("Mesh: Set Provisioner Authentication Reply");
 257         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_AUTHENTICATION_REPLY,
 258                         in_param1, in_param2, in_param3, in_param4, &out_param);
 259
 260         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 261
 262         return result;
 263 }
 264
 265 BT_EXPORT_API int bluetooth_mesh_network_set_name(
 266         bluetooth_mesh_network_t *network)
 267 {
 268         int result;
 269
 270         BT_CHECK_PARAMETER(network, return);
 271
 272         BT_INIT_PARAMS();
 273         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 274
 275         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 276
 277         BT_INFO("Mesh:Set Network Name");
 278         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_SET_NAME,
 279                         in_param1, in_param2, in_param3, in_param4, &out_param);
 280         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 281
 282         return result;
 283 }
 284
 285 BT_EXPORT_API int bluetooth_mesh_network_add_netkey(
 286                 bluetooth_mesh_network_t *network,
 287                         uint16_t *netkey_idx)
 288 {
 289         int result;
 290
 291         BT_CHECK_PARAMETER(network, return);
 292         BT_CHECK_PARAMETER(netkey_idx, return);
 293
 294         BT_INIT_PARAMS();
 295         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 296
 297         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 298
 299         BT_INFO("Mesh:Set Create Subnetwork key");
 300         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_ADD_NETKEY,
 301                         in_param1, in_param2, in_param3, in_param4, &out_param);
 302         if (result == BLUETOOTH_ERROR_NONE) {
 303                 *netkey_idx = g_array_index(out_param, guint16, 0);
 304         }
 305         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 306
 307         return result;
 308 }
 309
 310 BT_EXPORT_API int bluetooth_mesh_network_delete_netkey(
 311         bluetooth_mesh_network_t *network,
 312                 uint16_t netkey_idx)
 313 {
 314         int result;
 315
 316         BT_CHECK_PARAMETER(network, return);
 317
 318         BT_INIT_PARAMS();
 319         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 320
 321         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 322         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 323
 324         BT_INFO("Mesh: Delete Subnetwork key");
 325         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_DELETE_NETKEY,
 326                         in_param1, in_param2, in_param3, in_param4, &out_param);
 327         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 328
 329         return result;
 330 }
 331
 332 BT_EXPORT_API int bluetooth_mesh_network_update_netkey(
 333         bluetooth_mesh_network_t *network,
 334                 uint16_t netkey_idx)
 335 {
 336         int result;
 337
 338         BT_CHECK_PARAMETER(network, return);
 339
 340         BT_INIT_PARAMS();
 341         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 342
 343         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 344         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 345
 346         BT_INFO("Mesh: Update Subnetwork key");
 347         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_UPDATE_NETKEY,
 348                         in_param1, in_param2, in_param3, in_param4, &out_param);
 349         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 350
 351         return result;
 352 }
 353
 354 BT_EXPORT_API int bluetooth_mesh_network_add_appkey(
 355                 bluetooth_mesh_network_t *network,
 356                         uint16_t netkey_index,
 357                                 uint16_t *appkey_index)
 358 {
 359         int result;
 360
 361         BT_CHECK_PARAMETER(network, return);
 362         BT_CHECK_PARAMETER(appkey_index, return);
 363
 364         BT_INIT_PARAMS();
 365         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 366
 367         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 368         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 369
 370         BT_INFO("Mesh: Create AppKey");
 371         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_ADD_APPKEY,
 372                         in_param1, in_param2, in_param3, in_param4, &out_param);
 373
 374         if (result == BLUETOOTH_ERROR_NONE) {
 375                 *appkey_index = g_array_index(out_param, guint16, 0);
 376         }
 377         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 378
 379         return result;
 380 }
 381
 382 BT_EXPORT_API int bluetooth_mesh_network_update_appkey(
 383                 bluetooth_mesh_network_t *network,
 384                         uint16_t netkey_index, uint16_t appkey_index)
 385 {
 386         int result;
 387
 388         BT_CHECK_PARAMETER(network, return);
 389
 390         BT_INIT_PARAMS();
 391         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 392
 393         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 394         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 395         g_array_append_vals(in_param3, &appkey_index,  sizeof(guint16));
 396
 397         BT_INFO("Mesh:BTAPI: Update AppKey");
 398         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_UPDATE_APPKEY,
 399                         in_param1, in_param2, in_param3, in_param4, &out_param);
 400
 401         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 402
 403         return result;
 404 }
 405
 406 BT_EXPORT_API int bluetooth_mesh_network_delete_appkey(bluetooth_mesh_network_t *network,
 407                         uint16_t netkey_index, uint16_t appkey_index)
 408 {
 409         int result;
 410
 411         BT_CHECK_PARAMETER(network, return);
 412
 413         BT_INIT_PARAMS();
 414         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 415
 416         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 417         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 418         g_array_append_vals(in_param3, &appkey_index,  sizeof(guint16));
 419
 420         BT_INFO("Mesh: Delete AppKey");
 421         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_DELETE_APPKEY,
 422                         in_param1, in_param2, in_param3, in_param4, &out_param);
 423
 424         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 425
 426         return result;
 427 }
 428
 429 BT_EXPORT_API int bluetooth_mesh_network_get_all_nodes(
 430                 bluetooth_mesh_network_t *network,
 431                         GPtrArray **nodes)
 432 {
 433         int result = BLUETOOTH_ERROR_NONE;
 434         guint size;
 435         int i;
 436         bluetooth_mesh_node_info_t *info;
 437
 438         BT_CHECK_PARAMETER(network, return);
 439         BT_CHECK_PARAMETER(nodes, return);
 440
 441         BT_INIT_PARAMS();
 442         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 443
 444         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 445
 446         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_NODES,
 447                         in_param1, in_param2, in_param3, in_param4, &out_param);
 448
 449         if (result == BLUETOOTH_ERROR_NONE) {
 450                 if (out_param == NULL) {
 451                         BT_ERR("Mesh: out_param is NULL");
 452                         result = BLUETOOTH_ERROR_INTERNAL;
 453                 } else {
 454                         size = (out_param->len) / sizeof(bluetooth_mesh_node_info_t);
 455
 456                         for (i = 0; i < size; i++) {
 457                                 bluetooth_mesh_node_info_t *data;
 458
 459                                 info = &g_array_index(out_param,
 460                                                 bluetooth_mesh_node_info_t, i);
 461
 462                                 data= g_memdup(info, sizeof(bluetooth_mesh_node_info_t));
 463                                 g_ptr_array_add(*nodes, (gpointer)data);
 464                         }
 465                 }
 466         }
 467
 468         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 469
 470         return result;
 471 }
 472
 473 BT_EXPORT_API int bluetooth_mesh_element_get_all_models(
 474         bluetooth_mesh_network_t *network,
 475                 uint16_t node_addr, int elem_idx,
 476                         GPtrArray **models)
 477 {
 478         int result = BLUETOOTH_ERROR_NONE;
 479         guint size;
 480         int i;
 481
 482         BT_CHECK_PARAMETER(network, return);
 483         BT_CHECK_PARAMETER(models, return);
 484
 485         BT_INIT_PARAMS();
 486         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 487
 488         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 489         g_array_append_vals(in_param2, &node_addr,  sizeof(guint16));
 490         g_array_append_vals(in_param3, &elem_idx,  sizeof(int));
 491
 492         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_ELEMENT_GET_MODELS,
 493                         in_param1, in_param2, in_param3, in_param4, &out_param);
 494
 495         if (result == BLUETOOTH_ERROR_NONE) {
 496                 if (out_param == NULL) {
 497                         BT_ERR("Mesh: out_param is NULL");
 498                         result = BLUETOOTH_ERROR_INTERNAL;
 499                 } else {
 500                         size = (out_param->len) / sizeof(guint16);
 501
 502                         for (i = 0; i < size; i++) {
 503                                 uint32_t model_obj;
 504                                 uint32_t *model_ptr = NULL;
 505
 506                                 model_obj = g_array_index(out_param,
 507                                                 guint32, i);
 508
 509                                 model_ptr = g_memdup(&model_obj, sizeof(guint32));
 510                                 g_ptr_array_add(*models, (gpointer)model_ptr);
 511                         }
 512                 }
 513         }
 514
 515         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 516
 517         return result;
 518 }
 519
 520 BT_EXPORT_API int bluetooth_mesh_node_browse_vendor_features(
 521                         bluetooth_mesh_node_features_t *req)
 522 {
 523         int result;
 524         bt_user_info_t *user_info;
 525
 526         BT_CHECK_PARAMETER(req, return);
 527
 528         user_info = _bt_get_user_data(BT_MESH);
 529         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 530
 531         BT_INIT_PARAMS();
 532         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 533
 534         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_features_t));
 535
 536         BT_INFO("Mesh: Browse Vendor features of Node");
 537         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_VENDOR_FEATURES,
 538                         in_param1, in_param2, in_param3, in_param4,
 539                         user_info->cb, user_info->user_data);
 540
 541         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 542
 543         return result;
 544 }
 545
 546 BT_EXPORT_API int bluetooth_mesh_browse_remote_node(
 547                         bluetooth_mesh_node_discover_t *req)
 548 {
 549         int result;
 550         bt_user_info_t *user_info;
 551
 552         BT_CHECK_PARAMETER(req, return);
 553
 554         user_info = _bt_get_user_data(BT_MESH);
 555         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 556
 557         BT_INIT_PARAMS();
 558         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 559
 560         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_discover_t));
 561
 562         BT_INFO("Mesh: Browse remote Node");
 563         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_BROWSE,
 564                         in_param1, in_param2, in_param3, in_param4,
 565                         user_info->cb, user_info->user_data);
 566
 567         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 568
 569         return result;
 570 }
 571
 572 BT_EXPORT_API int bluetooth_mesh_node_ttl_execute(
 573                         bluetooth_mesh_node_ttl_info_t *req)
 574 {
 575         int result;
 576         bt_user_info_t *user_info;
 577
 578         BT_CHECK_PARAMETER(req, return);
 579
 580         user_info = _bt_get_user_data(BT_MESH);
 581         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 582
 583         BT_INIT_PARAMS();
 584         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 585
 586         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_ttl_info_t));
 587
 588         BT_INFO("Mesh: Node TTL Execute");
 589         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_TTL_EXECUTE,
 590                         in_param1, in_param2, in_param3, in_param4,
 591                         user_info->cb, user_info->user_data);
 592
 593         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 594
 595         return result;
 596 }
 597
 598 BT_EXPORT_API int bluetooth_mesh_model_configure_appkey(
 599                         bluetooth_mesh_model_configure_t *req)
 600 {
 601         int result;
 602         bt_user_info_t *user_info;
 603
 604         BT_CHECK_PARAMETER(req, return);
 605
 606         user_info = _bt_get_user_data(BT_MESH);
 607         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 608
 609         BT_INIT_PARAMS();
 610         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 611
 612         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 613
 614         BT_INFO("Mesh: Node Model Configure AppKey");
 615         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_CONFIGURE_APPKEY,
 616                         in_param1, in_param2, in_param3, in_param4,
 617                         user_info->cb, user_info->user_data);
 618
 619         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 620
 621         return result;
 622 }
 623
 624 BT_EXPORT_API int bluetooth_mesh_node_configure_key(
 625                         bluetooth_mesh_key_configure_t *req)
 626 {
 627         int result;
 628         bt_user_info_t *user_info;
 629
 630         BT_CHECK_PARAMETER(req, return);
 631
 632         user_info = _bt_get_user_data(BT_MESH);
 633         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 634
 635         BT_INIT_PARAMS();
 636         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 637
 638         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_key_configure_t));
 639
 640         BT_INFO("Mesh:BTAPI: Node Key Configure");
 641         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_CONFIGURE_KEY,
 642                         in_param1, in_param2, in_param3, in_param4,
 643                         user_info->cb, user_info->user_data);
 644
 645         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 646
 647         return result;
 648 }
 649
 650 BT_EXPORT_API int bluetooth_mesh_network_get_all_groups(
 651                 bluetooth_mesh_network_t *network,
 652                         GPtrArray **groups)
 653 {
 654         int result = BLUETOOTH_ERROR_NONE;
 655         guint size;
 656         int i;
 657
 658         BT_CHECK_PARAMETER(network, return);
 659         BT_CHECK_PARAMETER(groups, return);
 660
 661         BT_INIT_PARAMS();
 662         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 663
 664         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 665
 666         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_GROUPS,
 667                         in_param1, in_param2, in_param3, in_param4, &out_param);
 668
 669         if (result == BLUETOOTH_ERROR_NONE) {
 670                 if (out_param == NULL) {
 671                         BT_ERR("Mesh: out_param is NULL");
 672                         result = BLUETOOTH_ERROR_INTERNAL;
 673                 } else {
 674                         size = (out_param->len) / sizeof(guint16);
 675
 676                         if (size == 0) {
 677                                 BT_INFO("Mesh: No Groups created for the network");
 678                         }
 679
 680                         for (i = 0; i < size; i++) {
 681                                 uint16_t group_addr;
 682                                 uint16_t *group_ptr = NULL;
 683
 684                                 group_addr = g_array_index(out_param,
 685                                                 guint16, i);
 686
 687                                 group_ptr = g_memdup(&group_addr, sizeof(guint16));
 688                                 g_ptr_array_add(*groups, (gpointer)group_ptr);
 689                         }
 690                 }
 691         }
 692
 693         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 694
 695         return result;
 696 }
 697
 698 BT_EXPORT_API int bluetooth_mesh_network_get_all_netkey(
 699                 bluetooth_mesh_network_t *network,
 700                         GPtrArray **netkeys)
 701 {
 702         int result = BLUETOOTH_ERROR_NONE;
 703         guint size;
 704         int i;
 705
 706         BT_CHECK_PARAMETER(network, return);
 707         BT_CHECK_PARAMETER(netkeys, return);
 708
 709         BT_INIT_PARAMS();
 710         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 711
 712         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 713
 714         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_NETKEYS,
 715                         in_param1, in_param2, in_param3, in_param4, &out_param);
 716
 717         if (result == BLUETOOTH_ERROR_NONE) {
 718                 if (out_param == NULL) {
 719                         BT_ERR("Mesh: out_param is NULL");
 720                         result = BLUETOOTH_ERROR_INTERNAL;
 721                 } else {
 722                         size = (out_param->len) / sizeof(guint16);
 723
 724                         if (size == 0) {
 725                                 BT_ERR("Mesh: No netkeys created for the network");
 726                                 result = BLUETOOTH_ERROR_NOT_FOUND;
 727                         }
 728
 729                         for (i = 0; i < size; i++) {
 730                                 uint16_t netkey_index;
 731                                 uint16_t *netkey_idx = NULL;
 732
 733                                 netkey_index = g_array_index(out_param,
 734                                                 guint16, i);
 735
 736                                 netkey_idx = g_memdup(&netkey_index, sizeof(guint16));
 737                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
 738                         }
 739                 }
 740         }
 741
 742         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 743
 744         return result;
 745 }
 746
 747 BT_EXPORT_API int bluetooth_mesh_netkey_get_all_appkey(
 748                 bluetooth_mesh_network_t *network,
 749                         uint16_t netkey_idx,
 750                                 GPtrArray **appkeys)
 751 {
 752         int result = BLUETOOTH_ERROR_NONE;
 753         guint size;
 754         int i;
 755
 756         BT_CHECK_PARAMETER(network, return);
 757         BT_CHECK_PARAMETER(appkeys, return);
 758
 759         BT_INIT_PARAMS();
 760         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 761
 762         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 763         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 764
 765         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_APPKEYS,
 766                         in_param1, in_param2, in_param3, in_param4, &out_param);
 767
 768         if (result == BLUETOOTH_ERROR_NONE) {
 769                 if (out_param == NULL) {
 770                         BT_ERR("Mesh: out_param is NULL");
 771                         result = BLUETOOTH_ERROR_INTERNAL;
 772                 } else {
 773                         size = (out_param->len) / sizeof(guint16);
 774
 775                         if (size == 0) {
 776                                 BT_ERR("Mesh: No Appkeys created for the NetKey in the network");
 777                         }
 778
 779                         for (i = 0; i < size; i++) {
 780                                 uint16_t appkey_index;
 781                                 uint16_t *appkey_idx = NULL;
 782
 783                                 appkey_index = g_array_index(out_param,
 784                                                 guint16, i);
 785
 786                                 appkey_idx = g_memdup(&appkey_index, sizeof(guint16));
 787                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
 788                         }
 789                 }
 790         }
 791
 792         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 793
 794         return result;
 795 }
 796
 797 BT_EXPORT_API int bluetooth_mesh_node_get_all_netkeys(
 798                 bluetooth_mesh_node_discover_t *node,
 799                         GPtrArray **netkeys)
 800 {
 801         int result = BLUETOOTH_ERROR_NONE;
 802         guint size;
 803         int i;
 804
 805         BT_CHECK_PARAMETER(node, return);
 806         BT_CHECK_PARAMETER(netkeys, return);
 807
 808         BT_INIT_PARAMS();
 809         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 810
 811         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_discover_t));
 812
 813         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_NETKEYS,
 814                         in_param1, in_param2, in_param3, in_param4, &out_param);
 815
 816         if (result == BLUETOOTH_ERROR_NONE) {
 817                 if (out_param == NULL) {
 818                         BT_ERR("Mesh: out_param is NULL");
 819                         result = BLUETOOTH_ERROR_INTERNAL;
 820                 } else {
 821                         size = (out_param->len) / sizeof(guint16);
 822
 823                         for (i = 0; i < size; i++) {
 824                                 uint16_t netkey_index;
 825                                 uint16_t *netkey_idx = NULL;
 826
 827                                 netkey_index = g_array_index(out_param,
 828                                                 guint16, i);
 829
 830                                 netkey_idx = g_memdup(&netkey_index, sizeof(guint16));
 831                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
 832                         }
 833                 }
 834         }
 835
 836         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 837
 838         return result;
 839 }
 840
 841 BT_EXPORT_API int bluetooth_mesh_node_get_all_appkeys(
 842         bluetooth_mesh_node_discover_t *req, GPtrArray **appkeys)
 843 {
 844         int result = BLUETOOTH_ERROR_NONE;
 845         guint size;
 846         int i;
 847
 848         BT_CHECK_PARAMETER(req, return);
 849         BT_CHECK_PARAMETER(appkeys, return);
 850
 851         BT_INIT_PARAMS();
 852         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 853
 854         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_discover_t));
 855
 856         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_APPKEYS,
 857                         in_param1, in_param2, in_param3, in_param4, &out_param);
 858
 859         if (result == BLUETOOTH_ERROR_NONE) {
 860                 if (out_param == NULL) {
 861                         BT_ERR("Mesh: out_param is NULL");
 862                         result = BLUETOOTH_ERROR_INTERNAL;
 863                 } else {
 864                         size = (out_param->len) / sizeof(guint16);
 865
 866                         for (i = 0; i < size; i++) {
 867                                 uint16_t appkey_index;
 868                                 uint16_t *appkey_idx = NULL;
 869
 870                                 appkey_index = g_array_index(out_param,
 871                                                 guint16, i);
 872
 873                                 appkey_idx = g_memdup(&appkey_index, sizeof(guint16));
 874                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
 875                         }
 876                 }
 877         }
 878
 879         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 880
 881         return result;
 882 }
 883
 884 BT_EXPORT_API int bluetooth_mesh_model_get_all_appkeys(
 885                         bluetooth_mesh_model_configure_t *req)
 886 {
 887         int result = 0;
 888         bt_user_info_t *user_info;
 889
 890         BT_CHECK_PARAMETER(req, return);
 891
 892         user_info = _bt_get_user_data(BT_MESH);
 893         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 894
 895         BT_INIT_PARAMS();
 896         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 897
 898         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 899
 900         BT_INFO("Mesh:Node Model Get AppKey List ");
 901         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_APPKEY_LIST,
 902                         in_param1, in_param2, in_param3, in_param4,
 903                         user_info->cb, user_info->user_data);
 904
 905         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 906         return result;
 907 }
 908
 909 BT_EXPORT_API int bluetooth_mesh_model_set_publication(
 910                         bluetooth_mesh_model_configure_t *req)
 911 {
 912         int result = 0;
 913         bt_user_info_t *user_info;
 914
 915         BT_CHECK_PARAMETER(req, return);
 916
 917         user_info = _bt_get_user_data(BT_MESH);
 918         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 919
 920         BT_INIT_PARAMS();
 921         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 922
 923         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 924
 925         BT_INFO("Mesh: Model Set Publication");
 926         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_SET_PUBLICATION,
 927                         in_param1, in_param2, in_param3, in_param4,
 928                         user_info->cb, user_info->user_data);
 929
 930         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 931         return result;
 932 }
 933
 934 BT_EXPORT_API int bluetooth_mesh_model_get_publication(
 935                         bluetooth_mesh_model_configure_t *req)
 936 {
 937         int result = 0;
 938         bt_user_info_t *user_info;
 939
 940         BT_CHECK_PARAMETER(req, return);
 941
 942         user_info = _bt_get_user_data(BT_MESH);
 943         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 944
 945         BT_INIT_PARAMS();
 946         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 947
 948         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 949
 950         BT_INFO("Mesh:BTAPI:  Model Get Publication");
 951         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_PUBLICATION,
 952                         in_param1, in_param2, in_param3, in_param4,
 953                         user_info->cb, user_info->user_data);
 954
 955         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 956         return result;
 957 }
 958
 959 BT_EXPORT_API int bluetooth_mesh_model_get_subscriptopn_list(
 960                         bluetooth_mesh_model_configure_t *req)
 961 {
 962         int result = 0;
 963         bt_user_info_t *user_info;
 964
 965         BT_CHECK_PARAMETER(req, return);
 966
 967         user_info = _bt_get_user_data(BT_MESH);
 968         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 969
 970         BT_INIT_PARAMS();
 971         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 972
 973         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 974
 975         BT_INFO("Mesh:BTAPI:  Model Get Subscription List ");
 976         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_SUBSCRIPTION_LIST,
 977                         in_param1, in_param2, in_param3, in_param4,
 978                         user_info->cb, user_info->user_data);
 979
 980         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 981         return result;
 982 }
 983
 984 BT_EXPORT_API int bluetooth_mesh_network_create_group(
 985                 bluetooth_mesh_network_t *network, bool is_virtual,
 986                         uint16_t grp_addr, bluetooth_mesh_network_group_info_t *info)
 987 {
 988         int result;
 989
 990         BT_CHECK_PARAMETER(network, return);
 991         BT_CHECK_PARAMETER(info, return);
 992
 993         BT_INIT_PARAMS();
 994         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 995
 996         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 997         g_array_append_vals(in_param2, &is_virtual,  sizeof(gboolean));
 998         g_array_append_vals(in_param3, &grp_addr,  sizeof(guint16));
 999
1000         BT_INFO("Mesh: Create Group Request");
1001         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_CREATE_GROUP,
1002                         in_param1, in_param2, in_param3, in_param4, &out_param);
1003
1004         if (result == BLUETOOTH_ERROR_NONE) {
1005                 *info = g_array_index(out_param,
1006                                 bluetooth_mesh_network_group_info_t, 0);
1007         }
1008         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1009
1010         return result;
1011 }
1012
1013 BT_EXPORT_API int bluetooth_mesh_model_configure_group_sub(
1014                         bluetooth_mesh_model_configure_t *req)
1015 {
1016         int result = 0;
1017         bt_user_info_t *user_info;
1018
1019         BT_CHECK_PARAMETER(req, return);
1020
1021         user_info = _bt_get_user_data(BT_MESH);
1022         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1023
1024         BT_INIT_PARAMS();
1025         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1026
1027         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1028
1029         BT_INFO("Mesh:Model Group Subscription Request");
1030         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_CONFIG_GROUP_SUB,
1031                         in_param1, in_param2, in_param3, in_param4,
1032                         user_info->cb, user_info->user_data);
1033
1034         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1035         return result;
1036 }
1037
1038 BT_EXPORT_API int bluetooth_mesh_model_configure_virtual_group_sub(
1039                         bluetooth_mesh_model_configure_t *req)
1040 {
1041         int result = 0;
1042         bt_user_info_t *user_info;
1043
1044         BT_CHECK_PARAMETER(req, return);
1045
1046         user_info = _bt_get_user_data(BT_MESH);
1047         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1048
1049         BT_INIT_PARAMS();
1050         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1051
1052         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1053
1054         BT_INFO("Mesh: Model Virtual Group Subscription Request");
1055         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
1056                         BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB,
1057                         in_param1, in_param2, in_param3, in_param4,
1058                         user_info->cb, user_info->user_data);
1059
1060         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1061         return result;
1062 }