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