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                                 result = BLUETOOTH_ERROR_NOT_FOUND;
 778                         }
 779
 780                         for (i = 0; i < size; i++) {
 781                                 uint16_t appkey_index;
 782                                 uint16_t *appkey_idx = NULL;
 783
 784                                 appkey_index = g_array_index(out_param,
 785                                                 guint16, i);
 786
 787                                 appkey_idx = g_memdup(&appkey_index, sizeof(guint16));
 788                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
 789                         }
 790                 }
 791         }
 792
 793         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 794
 795         return result;
 796 }
 797
 798 BT_EXPORT_API int bluetooth_mesh_node_get_all_netkeys(
 799                 bluetooth_mesh_node_discover_t *node,
 800                         GPtrArray **netkeys)
 801 {
 802         int result = BLUETOOTH_ERROR_NONE;
 803         guint size;
 804         int i;
 805
 806         BT_CHECK_PARAMETER(node, return);
 807         BT_CHECK_PARAMETER(netkeys, return);
 808
 809         BT_INIT_PARAMS();
 810         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 811
 812         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_discover_t));
 813
 814         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_NETKEYS,
 815                         in_param1, in_param2, in_param3, in_param4, &out_param);
 816
 817         if (result == BLUETOOTH_ERROR_NONE) {
 818                 if (out_param == NULL) {
 819                         BT_ERR("Mesh: out_param is NULL");
 820                         result = BLUETOOTH_ERROR_INTERNAL;
 821                 } else {
 822                         size = (out_param->len) / sizeof(guint16);
 823
 824                         for (i = 0; i < size; i++) {
 825                                 uint16_t netkey_index;
 826                                 uint16_t *netkey_idx = NULL;
 827
 828                                 netkey_index = g_array_index(out_param,
 829                                                 guint16, i);
 830
 831                                 netkey_idx = g_memdup(&netkey_index, sizeof(guint16));
 832                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
 833                         }
 834                 }
 835         }
 836
 837         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 838
 839         return result;
 840 }
 841
 842 BT_EXPORT_API int bluetooth_mesh_node_get_all_appkeys(
 843         bluetooth_mesh_node_discover_t *req, GPtrArray **appkeys)
 844 {
 845         int result = BLUETOOTH_ERROR_NONE;
 846         guint size;
 847         int i;
 848
 849         BT_CHECK_PARAMETER(req, return);
 850         BT_CHECK_PARAMETER(appkeys, return);
 851
 852         BT_INIT_PARAMS();
 853         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 854
 855         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_discover_t));
 856
 857         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_APPKEYS,
 858                         in_param1, in_param2, in_param3, in_param4, &out_param);
 859
 860         if (result == BLUETOOTH_ERROR_NONE) {
 861                 if (out_param == NULL) {
 862                         BT_ERR("Mesh: out_param is NULL");
 863                         result = BLUETOOTH_ERROR_INTERNAL;
 864                 } else {
 865                         size = (out_param->len) / sizeof(guint16);
 866
 867                         for (i = 0; i < size; i++) {
 868                                 uint16_t appkey_index;
 869                                 uint16_t *appkey_idx = NULL;
 870
 871                                 appkey_index = g_array_index(out_param,
 872                                                 guint16, i);
 873
 874                                 appkey_idx = g_memdup(&appkey_index, sizeof(guint16));
 875                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
 876                         }
 877                 }
 878         }
 879
 880         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 881
 882         return result;
 883 }
 884
 885 BT_EXPORT_API int bluetooth_mesh_model_get_all_appkeys(
 886                         bluetooth_mesh_model_configure_t *req)
 887 {
 888         int result = 0;
 889         bt_user_info_t *user_info;
 890
 891         BT_CHECK_PARAMETER(req, return);
 892
 893         user_info = _bt_get_user_data(BT_MESH);
 894         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 895
 896         BT_INIT_PARAMS();
 897         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 898
 899         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 900
 901         BT_INFO("Mesh:Node Model Get AppKey List ");
 902         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_APPKEY_LIST,
 903                         in_param1, in_param2, in_param3, in_param4,
 904                         user_info->cb, user_info->user_data);
 905
 906         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 907         return result;
 908 }
 909
 910 BT_EXPORT_API int bluetooth_mesh_model_set_publication(
 911                         bluetooth_mesh_model_configure_t *req)
 912 {
 913         int result = 0;
 914         bt_user_info_t *user_info;
 915
 916         BT_CHECK_PARAMETER(req, return);
 917
 918         user_info = _bt_get_user_data(BT_MESH);
 919         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 920
 921         BT_INIT_PARAMS();
 922         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 923
 924         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 925
 926         BT_INFO("Mesh: Model Set Publication");
 927         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_SET_PUBLICATION,
 928                         in_param1, in_param2, in_param3, in_param4,
 929                         user_info->cb, user_info->user_data);
 930
 931         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 932         return result;
 933 }
 934
 935 BT_EXPORT_API int bluetooth_mesh_model_get_publication(
 936                         bluetooth_mesh_model_configure_t *req)
 937 {
 938         int result = 0;
 939         bt_user_info_t *user_info;
 940
 941         BT_CHECK_PARAMETER(req, return);
 942
 943         user_info = _bt_get_user_data(BT_MESH);
 944         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 945
 946         BT_INIT_PARAMS();
 947         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 948
 949         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 950
 951         BT_INFO("Mesh:BTAPI:  Model Get Publication");
 952         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_PUBLICATION,
 953                         in_param1, in_param2, in_param3, in_param4,
 954                         user_info->cb, user_info->user_data);
 955
 956         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 957         return result;
 958 }
 959
 960 BT_EXPORT_API int bluetooth_mesh_model_get_subscriptopn_list(
 961                         bluetooth_mesh_model_configure_t *req)
 962 {
 963         int result = 0;
 964         bt_user_info_t *user_info;
 965
 966         BT_CHECK_PARAMETER(req, return);
 967
 968         user_info = _bt_get_user_data(BT_MESH);
 969         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 970
 971         BT_INIT_PARAMS();
 972         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 973
 974         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 975
 976         BT_INFO("Mesh:BTAPI:  Model Get Subscription List ");
 977         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_SUBSCRIPTION_LIST,
 978                         in_param1, in_param2, in_param3, in_param4,
 979                         user_info->cb, user_info->user_data);
 980
 981         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 982         return result;
 983 }
 984
 985 BT_EXPORT_API int bluetooth_mesh_network_create_group(
 986                 bluetooth_mesh_network_t *network, bool is_virtual,
 987                         uint16_t grp_addr, bluetooth_mesh_network_group_info_t *info)
 988 {
 989         int result;
 990
 991         BT_CHECK_PARAMETER(network, return);
 992         BT_CHECK_PARAMETER(info, return);
 993
 994         BT_INIT_PARAMS();
 995         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 996
 997         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 998         g_array_append_vals(in_param2, &is_virtual,  sizeof(gboolean));
 999         g_array_append_vals(in_param3, &grp_addr,  sizeof(guint16));
1000
1001         BT_INFO("Mesh: Create Group Request");
1002         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_CREATE_GROUP,
1003                         in_param1, in_param2, in_param3, in_param4, &out_param);
1004
1005         if (result == BLUETOOTH_ERROR_NONE) {
1006                 *info = g_array_index(out_param,
1007                                 bluetooth_mesh_network_group_info_t, 0);
1008         }
1009         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1010
1011         return result;
1012 }
1013
1014 BT_EXPORT_API int bluetooth_mesh_model_configure_group_sub(
1015                         bluetooth_mesh_model_configure_t *req)
1016 {
1017         int result = 0;
1018         bt_user_info_t *user_info;
1019
1020         BT_CHECK_PARAMETER(req, return);
1021
1022         user_info = _bt_get_user_data(BT_MESH);
1023         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1024
1025         BT_INIT_PARAMS();
1026         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1027
1028         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1029
1030         BT_INFO("Mesh:Model Group Subscription Request");
1031         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_CONFIG_GROUP_SUB,
1032                         in_param1, in_param2, in_param3, in_param4,
1033                         user_info->cb, user_info->user_data);
1034
1035         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1036         return result;
1037 }
1038
1039 BT_EXPORT_API int bluetooth_mesh_model_configure_virtual_group_sub(
1040                         bluetooth_mesh_model_configure_t *req)
1041 {
1042         int result = 0;
1043         bt_user_info_t *user_info;
1044
1045         BT_CHECK_PARAMETER(req, return);
1046
1047         user_info = _bt_get_user_data(BT_MESH);
1048         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1049
1050         BT_INIT_PARAMS();
1051         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1052
1053         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1054
1055         BT_INFO("Mesh: Model Virtual Group Subscription Request");
1056         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
1057                         BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB,
1058                         in_param1, in_param2, in_param3, in_param4,
1059                         user_info->cb, user_info->user_data);
1060
1061         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1062         return result;
1063 }