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         }
 334         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 335
 336         return result;
 337 }
 338
 339 BT_EXPORT_API int bluetooth_mesh_network_delete_netkey(
 340         bluetooth_mesh_network_t *network,
 341                 uint16_t netkey_idx)
 342 {
 343         int result;
 344
 345         BT_CHECK_PARAMETER(network, return);
 346
 347         BT_INIT_PARAMS();
 348         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 349
 350         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 351         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 352
 353         BT_INFO("Mesh: Delete Subnetwork key");
 354         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_DELETE_NETKEY,
 355                         in_param1, in_param2, in_param3, in_param4, &out_param);
 356         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 357
 358         return result;
 359 }
 360
 361 BT_EXPORT_API int bluetooth_mesh_network_update_netkey(
 362         bluetooth_mesh_network_t *network,
 363                 uint16_t netkey_idx)
 364 {
 365         int result;
 366
 367         BT_CHECK_PARAMETER(network, return);
 368
 369         BT_INIT_PARAMS();
 370         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 371
 372         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 373         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 374
 375         BT_INFO("Mesh: Update Subnetwork key");
 376         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_UPDATE_NETKEY,
 377                         in_param1, in_param2, in_param3, in_param4, &out_param);
 378         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 379
 380         return result;
 381 }
 382
 383 BT_EXPORT_API int bluetooth_mesh_network_add_appkey(
 384                 bluetooth_mesh_network_t *network,
 385                         uint16_t netkey_index,
 386                                 uint16_t *appkey_index)
 387 {
 388         int result;
 389
 390         BT_CHECK_PARAMETER(network, return);
 391         BT_CHECK_PARAMETER(appkey_index, return);
 392
 393         BT_INIT_PARAMS();
 394         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 395
 396         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 397         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 398
 399         BT_INFO("Mesh: Create AppKey");
 400         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_ADD_APPKEY,
 401                         in_param1, in_param2, in_param3, in_param4, &out_param);
 402
 403         if (result == BLUETOOTH_ERROR_NONE) {
 404                 *appkey_index = g_array_index(out_param, guint16, 0);
 405         }
 406         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 407
 408         return result;
 409 }
 410
 411 BT_EXPORT_API int bluetooth_mesh_network_update_appkey(
 412                 bluetooth_mesh_network_t *network,
 413                         uint16_t netkey_index, uint16_t appkey_index)
 414 {
 415         int result;
 416
 417         BT_CHECK_PARAMETER(network, return);
 418
 419         BT_INIT_PARAMS();
 420         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 421
 422         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 423         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 424         g_array_append_vals(in_param3, &appkey_index,  sizeof(guint16));
 425
 426         BT_INFO("Mesh:BTAPI: Update AppKey");
 427         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_UPDATE_APPKEY,
 428                         in_param1, in_param2, in_param3, in_param4, &out_param);
 429
 430         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 431
 432         return result;
 433 }
 434
 435 BT_EXPORT_API int bluetooth_mesh_network_delete_appkey(bluetooth_mesh_network_t *network,
 436                         uint16_t netkey_index, uint16_t appkey_index)
 437 {
 438         int result;
 439
 440         BT_CHECK_PARAMETER(network, return);
 441
 442         BT_INIT_PARAMS();
 443         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 444
 445         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 446         g_array_append_vals(in_param2, &netkey_index,  sizeof(guint16));
 447         g_array_append_vals(in_param3, &appkey_index,  sizeof(guint16));
 448
 449         BT_INFO("Mesh: Delete AppKey");
 450         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_DELETE_APPKEY,
 451                         in_param1, in_param2, in_param3, in_param4, &out_param);
 452
 453         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 454
 455         return result;
 456 }
 457
 458 BT_EXPORT_API int bluetooth_mesh_network_get_all_nodes(
 459                 bluetooth_mesh_network_t *network,
 460                         GPtrArray **nodes)
 461 {
 462         int result = BLUETOOTH_ERROR_NONE;
 463         guint size;
 464         int i;
 465         bluetooth_mesh_node_info_t *info;
 466
 467         BT_CHECK_PARAMETER(network, return);
 468         BT_CHECK_PARAMETER(nodes, return);
 469
 470         BT_INIT_PARAMS();
 471         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 472
 473         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 474
 475         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_NODES,
 476                         in_param1, in_param2, in_param3, in_param4, &out_param);
 477
 478         if (result == BLUETOOTH_ERROR_NONE) {
 479                 if (out_param == NULL) {
 480                         BT_ERR("Mesh: out_param is NULL");
 481                         result = BLUETOOTH_ERROR_INTERNAL;
 482                 } else {
 483                         size = (out_param->len) / sizeof(bluetooth_mesh_node_info_t);
 484
 485                         for (i = 0; i < size; i++) {
 486                                 bluetooth_mesh_node_info_t *data;
 487
 488                                 info = &g_array_index(out_param,
 489                                                 bluetooth_mesh_node_info_t, i);
 490
 491                                 data= g_memdup(info, sizeof(bluetooth_mesh_node_info_t));
 492                                 g_ptr_array_add(*nodes, (gpointer)data);
 493                         }
 494                 }
 495         }
 496
 497         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 498
 499         return result;
 500 }
 501
 502 BT_EXPORT_API int bluetooth_mesh_element_get_all_models(
 503         bluetooth_mesh_network_t *network,
 504                 uint16_t node_addr, int elem_idx,
 505                         GPtrArray **models)
 506 {
 507         int result = BLUETOOTH_ERROR_NONE;
 508         guint size;
 509         int i;
 510
 511         BT_CHECK_PARAMETER(network, return);
 512         BT_CHECK_PARAMETER(models, return);
 513
 514         BT_INIT_PARAMS();
 515         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 516
 517         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 518         g_array_append_vals(in_param2, &node_addr,  sizeof(guint16));
 519         g_array_append_vals(in_param3, &elem_idx,  sizeof(int));
 520
 521         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_ELEMENT_GET_MODELS,
 522                         in_param1, in_param2, in_param3, in_param4, &out_param);
 523
 524         if (result == BLUETOOTH_ERROR_NONE) {
 525                 if (out_param == NULL) {
 526                         BT_ERR("Mesh: out_param is NULL");
 527                         result = BLUETOOTH_ERROR_INTERNAL;
 528                 } else {
 529                         size = (out_param->len) / sizeof(guint32);
 530                         BT_INFO("Mesh: Total Models found in Element [%d]", size);
 531
 532                         for (i = 0; i < size; i++) {
 533                                 uint32_t model_obj;
 534                                 uint32_t *model_ptr = NULL;
 535
 536                                 model_obj = g_array_index(out_param,
 537                                                 guint32, i);
 538
 539                                 model_ptr = g_memdup(&model_obj, sizeof(guint32));
 540                                 g_ptr_array_add(*models, (gpointer)model_ptr);
 541                         }
 542                 }
 543         }
 544
 545         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 546
 547         return result;
 548 }
 549
 550 BT_EXPORT_API int bluetooth_mesh_node_browse_vendor_features(
 551                         bluetooth_mesh_node_features_t *req)
 552 {
 553         int result;
 554         bt_user_info_t *user_info;
 555
 556         BT_CHECK_PARAMETER(req, return);
 557
 558         user_info = _bt_get_user_data(BT_MESH);
 559         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 560
 561         BT_INIT_PARAMS();
 562         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 563
 564         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_features_t));
 565
 566         BT_INFO("Mesh: Browse Vendor features of Node");
 567         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_VENDOR_FEATURES,
 568                         in_param1, in_param2, in_param3, in_param4,
 569                         user_info->cb, user_info->user_data);
 570
 571         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 572
 573         return result;
 574 }
 575
 576 BT_EXPORT_API int bluetooth_mesh_browse_remote_node(
 577                         bluetooth_mesh_node_discover_t *req)
 578 {
 579         int result;
 580         bt_user_info_t *user_info;
 581
 582         BT_CHECK_PARAMETER(req, return);
 583
 584         user_info = _bt_get_user_data(BT_MESH);
 585         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 586
 587         BT_INIT_PARAMS();
 588         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 589
 590         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_discover_t));
 591
 592         BT_INFO("Mesh: Browse remote Node");
 593         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_BROWSE,
 594                         in_param1, in_param2, in_param3, in_param4,
 595                         user_info->cb, user_info->user_data);
 596
 597         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 598
 599         return result;
 600 }
 601
 602 BT_EXPORT_API int bluetooth_mesh_node_ttl_execute(
 603                         bluetooth_mesh_node_ttl_info_t *req)
 604 {
 605         int result;
 606         bt_user_info_t *user_info;
 607
 608         BT_CHECK_PARAMETER(req, return);
 609
 610         user_info = _bt_get_user_data(BT_MESH);
 611         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 612
 613         BT_INIT_PARAMS();
 614         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 615
 616         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_ttl_info_t));
 617
 618         BT_INFO("Mesh: Node TTL Execute");
 619         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_TTL_EXECUTE,
 620                         in_param1, in_param2, in_param3, in_param4,
 621                         user_info->cb, user_info->user_data);
 622
 623         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 624
 625         return result;
 626 }
 627
 628 BT_EXPORT_API int bluetooth_mesh_model_configure_appkey(
 629                         bluetooth_mesh_model_configure_t *req)
 630 {
 631         int result;
 632         bt_user_info_t *user_info;
 633
 634         BT_CHECK_PARAMETER(req, return);
 635
 636         user_info = _bt_get_user_data(BT_MESH);
 637         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 638
 639         BT_INIT_PARAMS();
 640         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 641
 642         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 643
 644         BT_INFO("Mesh: Node Model Configure AppKey");
 645         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_CONFIGURE_APPKEY,
 646                         in_param1, in_param2, in_param3, in_param4,
 647                         user_info->cb, user_info->user_data);
 648
 649         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 650
 651         return result;
 652 }
 653
 654 BT_EXPORT_API int bluetooth_mesh_model_send_msg(
 655                         bluetooth_mesh_model_msg_t *req)
 656 {
 657         int result;
 658         bt_user_info_t *user_info;
 659
 660         BT_CHECK_PARAMETER(req, return);
 661
 662         user_info = _bt_get_user_data(BT_MESH);
 663         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 664
 665         BT_INIT_PARAMS();
 666         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 667
 668         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_msg_t));
 669
 670         BT_INFO("Mesh: Node Model Send Msg");
 671         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_EXECUTE_MSG,
 672                         in_param1, in_param2, in_param3, in_param4,
 673                         user_info->cb, user_info->user_data);
 674
 675         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 676
 677         return result;
 678 }
 679
 680 BT_EXPORT_API int bluetooth_mesh_node_configure_key(
 681                         bluetooth_mesh_key_configure_t *req)
 682 {
 683         int result;
 684         bt_user_info_t *user_info;
 685
 686         BT_CHECK_PARAMETER(req, return);
 687
 688         user_info = _bt_get_user_data(BT_MESH);
 689         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 690
 691         BT_INIT_PARAMS();
 692         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 693
 694         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_key_configure_t));
 695
 696         BT_INFO("Mesh:BTAPI: Node Key Configure");
 697         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_NODE_CONFIGURE_KEY,
 698                         in_param1, in_param2, in_param3, in_param4,
 699                         user_info->cb, user_info->user_data);
 700
 701         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 702
 703         return result;
 704 }
 705
 706 BT_EXPORT_API int bluetooth_mesh_network_get_all_groups(
 707                 bluetooth_mesh_network_t *network,
 708                         GPtrArray **groups)
 709 {
 710         int result = BLUETOOTH_ERROR_NONE;
 711         bluetooth_mesh_network_group_info_t *info;
 712         guint size;
 713         int i;
 714
 715         BT_CHECK_PARAMETER(network, return);
 716         BT_CHECK_PARAMETER(groups, return);
 717
 718         BT_INIT_PARAMS();
 719         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 720
 721         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 722
 723         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_GROUPS,
 724                         in_param1, in_param2, in_param3, in_param4, &out_param);
 725
 726         if (result == BLUETOOTH_ERROR_NONE) {
 727                 if (out_param == NULL) {
 728                         BT_ERR("Mesh: out_param is NULL");
 729                         result = BLUETOOTH_ERROR_INTERNAL;
 730                 } else {
 731                         size = (out_param->len) / sizeof(bluetooth_mesh_network_group_info_t);
 732
 733                         if (size == 0) {
 734                                 BT_INFO("Mesh: No Groups created for the network");
 735                         }
 736
 737                         BT_INFO("Mesh: Total groups [%d]", size);
 738                         for (i = 0; i < size; i++) {
 739                                 bluetooth_mesh_network_group_info_t *grp_info = NULL;
 740
 741                                 info = &g_array_index(out_param,
 742                                         bluetooth_mesh_network_group_info_t, i);
 743                                 BT_INFO("Mesh: Group addr [0x%2.2x]", info->group_addr);
 744                                 BT_INFO("Mesh: Group is Virtual [%s]", info->is_virtual? "YES":"NO");
 745                                 BT_INFO("Mesh: Group net UUID[%s]", info->net_uuid);
 746                                 if (info->is_virtual)
 747                                         BT_INFO("Mesh: Virual Label UUID [%s]", info->label_uuid);
 748                                 grp_info = g_memdup(info,
 749                                         sizeof(bluetooth_mesh_network_group_info_t));
 750                                 g_ptr_array_add(*groups, (gpointer)grp_info);
 751                         }
 752                 }
 753         }
 754
 755         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 756
 757         return result;
 758 }
 759
 760 BT_EXPORT_API int bluetooth_mesh_network_get_all_netkey(
 761                 bluetooth_mesh_network_t *network,
 762                         GPtrArray **netkeys)
 763 {
 764         int result = BLUETOOTH_ERROR_NONE;
 765         guint size;
 766         int i;
 767
 768         BT_CHECK_PARAMETER(network, return);
 769         BT_CHECK_PARAMETER(netkeys, return);
 770
 771         BT_INIT_PARAMS();
 772         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 773
 774         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 775
 776         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_NETKEYS,
 777                         in_param1, in_param2, in_param3, in_param4, &out_param);
 778
 779         if (result == BLUETOOTH_ERROR_NONE) {
 780                 if (out_param == NULL) {
 781                         BT_ERR("Mesh: out_param is NULL");
 782                         result = BLUETOOTH_ERROR_INTERNAL;
 783                 } else {
 784                         size = (out_param->len) / sizeof(guint16);
 785
 786                         if (size == 0) {
 787                                 BT_ERR("Mesh: No netkeys created for the network");
 788                                 result = BLUETOOTH_ERROR_NOT_FOUND;
 789                         }
 790
 791                         for (i = 0; i < size; i++) {
 792                                 uint16_t netkey_index;
 793                                 uint16_t *netkey_idx = NULL;
 794
 795                                 netkey_index = g_array_index(out_param,
 796                                                 guint16, i);
 797
 798                                 netkey_idx = g_memdup(&netkey_index, sizeof(guint16));
 799                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
 800                         }
 801                 }
 802         }
 803
 804         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 805
 806         return result;
 807 }
 808
 809 BT_EXPORT_API int bluetooth_mesh_netkey_get_all_appkey(
 810                 bluetooth_mesh_network_t *network,
 811                         uint16_t netkey_idx,
 812                                 GPtrArray **appkeys)
 813 {
 814         int result = BLUETOOTH_ERROR_NONE;
 815         guint size;
 816         int i;
 817
 818         BT_CHECK_PARAMETER(network, return);
 819         BT_CHECK_PARAMETER(appkeys, return);
 820
 821         BT_INIT_PARAMS();
 822         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 823
 824         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
 825         g_array_append_vals(in_param2, &netkey_idx,  sizeof(guint16));
 826
 827         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_GET_APPKEYS,
 828                         in_param1, in_param2, in_param3, in_param4, &out_param);
 829
 830         if (result == BLUETOOTH_ERROR_NONE) {
 831                 if (out_param == NULL) {
 832                         BT_ERR("Mesh: out_param is NULL");
 833                         result = BLUETOOTH_ERROR_INTERNAL;
 834                 } else {
 835                         size = (out_param->len) / sizeof(guint16);
 836
 837                         if (size == 0) {
 838                                 BT_ERR("Mesh: No Appkeys created for the NetKey in the network");
 839                         }
 840
 841                         for (i = 0; i < size; i++) {
 842                                 uint16_t appkey_index;
 843                                 uint16_t *appkey_idx = NULL;
 844
 845                                 appkey_index = g_array_index(out_param,
 846                                                 guint16, i);
 847
 848                                 appkey_idx = g_memdup(&appkey_index, sizeof(guint16));
 849                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
 850                         }
 851                 }
 852         }
 853
 854         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 855
 856         return result;
 857 }
 858
 859 BT_EXPORT_API int bluetooth_mesh_node_get_all_netkeys(
 860                 bluetooth_mesh_node_discover_t *node,
 861                         GPtrArray **netkeys)
 862 {
 863         int result = BLUETOOTH_ERROR_NONE;
 864         guint size;
 865         int i;
 866
 867         BT_CHECK_PARAMETER(node, return);
 868         BT_CHECK_PARAMETER(netkeys, return);
 869
 870         BT_INIT_PARAMS();
 871         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 872
 873         g_array_append_vals(in_param1, node,  sizeof(bluetooth_mesh_node_discover_t));
 874
 875         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_NETKEYS,
 876                         in_param1, in_param2, in_param3, in_param4, &out_param);
 877
 878         if (result == BLUETOOTH_ERROR_NONE) {
 879                 if (out_param == NULL) {
 880                         BT_ERR("Mesh: out_param is NULL");
 881                         result = BLUETOOTH_ERROR_INTERNAL;
 882                 } else {
 883                         size = (out_param->len) / sizeof(guint16);
 884
 885                         for (i = 0; i < size; i++) {
 886                                 uint16_t netkey_index;
 887                                 uint16_t *netkey_idx = NULL;
 888
 889                                 netkey_index = g_array_index(out_param,
 890                                                 guint16, i);
 891
 892                                 netkey_idx = g_memdup(&netkey_index, sizeof(guint16));
 893                                 g_ptr_array_add(*netkeys, (gpointer)netkey_idx);
 894                         }
 895                 }
 896         }
 897
 898         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 899
 900         return result;
 901 }
 902
 903 BT_EXPORT_API int bluetooth_mesh_node_get_all_appkeys(
 904         bluetooth_mesh_node_discover_t *req, GPtrArray **appkeys)
 905 {
 906         int result = BLUETOOTH_ERROR_NONE;
 907         guint size;
 908         int i;
 909
 910         BT_CHECK_PARAMETER(req, return);
 911         BT_CHECK_PARAMETER(appkeys, return);
 912
 913         BT_INIT_PARAMS();
 914         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 915
 916         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_node_discover_t));
 917
 918         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NODE_GET_APPKEYS,
 919                         in_param1, in_param2, in_param3, in_param4, &out_param);
 920
 921         if (result == BLUETOOTH_ERROR_NONE) {
 922                 if (out_param == NULL) {
 923                         BT_ERR("Mesh: out_param is NULL");
 924                         result = BLUETOOTH_ERROR_INTERNAL;
 925                 } else {
 926                         size = (out_param->len) / sizeof(guint16);
 927
 928                         for (i = 0; i < size; i++) {
 929                                 uint16_t appkey_index;
 930                                 uint16_t *appkey_idx = NULL;
 931
 932                                 appkey_index = g_array_index(out_param,
 933                                                 guint16, i);
 934
 935                                 appkey_idx = g_memdup(&appkey_index, sizeof(guint16));
 936                                 g_ptr_array_add(*appkeys, (gpointer)appkey_idx);
 937                         }
 938                 }
 939         }
 940
 941         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 942
 943         return result;
 944 }
 945
 946 BT_EXPORT_API int bluetooth_mesh_model_get_all_appkeys(
 947                         bluetooth_mesh_model_configure_t *req)
 948 {
 949         int result = 0;
 950         bt_user_info_t *user_info;
 951
 952         BT_CHECK_PARAMETER(req, return);
 953
 954         user_info = _bt_get_user_data(BT_MESH);
 955         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 956
 957         BT_INIT_PARAMS();
 958         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 959
 960         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 961
 962         BT_INFO("Mesh:Node Model Get AppKey List ");
 963         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_APPKEY_LIST,
 964                         in_param1, in_param2, in_param3, in_param4,
 965                         user_info->cb, user_info->user_data);
 966
 967         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 968         return result;
 969 }
 970
 971 BT_EXPORT_API int bluetooth_mesh_model_set_publication(
 972                         bluetooth_mesh_model_configure_t *req)
 973 {
 974         int result = 0;
 975         bt_user_info_t *user_info;
 976
 977         BT_CHECK_PARAMETER(req, return);
 978
 979         user_info = _bt_get_user_data(BT_MESH);
 980         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
 981
 982         BT_INIT_PARAMS();
 983         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 984
 985         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
 986
 987         BT_INFO("Mesh: Model Set Publication");
 988         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_SET_PUBLICATION,
 989                         in_param1, in_param2, in_param3, in_param4,
 990                         user_info->cb, user_info->user_data);
 991
 992         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 993         return result;
 994 }
 995
 996 BT_EXPORT_API int bluetooth_mesh_model_get_publication(
 997                         bluetooth_mesh_model_configure_t *req)
 998 {
 999         int result = 0;
1000         bt_user_info_t *user_info;
1001
1002         BT_CHECK_PARAMETER(req, return);
1003
1004         user_info = _bt_get_user_data(BT_MESH);
1005         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1006
1007         BT_INIT_PARAMS();
1008         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1009
1010         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1011
1012         BT_INFO("Mesh:BTAPI:  Model Get Publication");
1013         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_PUBLICATION,
1014                         in_param1, in_param2, in_param3, in_param4,
1015                         user_info->cb, user_info->user_data);
1016
1017         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1018         return result;
1019 }
1020
1021 BT_EXPORT_API int bluetooth_mesh_model_get_subscriptopn_list(
1022                         bluetooth_mesh_model_configure_t *req)
1023 {
1024         int result = 0;
1025         bt_user_info_t *user_info;
1026
1027         BT_CHECK_PARAMETER(req, return);
1028
1029         user_info = _bt_get_user_data(BT_MESH);
1030         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1031
1032         BT_INIT_PARAMS();
1033         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1034
1035         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1036
1037         BT_INFO("Mesh:BTAPI:  Model Get Subscription List ");
1038         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_GET_SUBSCRIPTION_LIST,
1039                         in_param1, in_param2, in_param3, in_param4,
1040                         user_info->cb, user_info->user_data);
1041
1042         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1043         return result;
1044 }
1045
1046 BT_EXPORT_API int bluetooth_mesh_network_remove_group(
1047                 bluetooth_mesh_network_t *network,
1048                         bluetooth_mesh_network_group_info_t *req)
1049 {
1050         int result;
1051
1052         BT_CHECK_PARAMETER(network, return);
1053         BT_CHECK_PARAMETER(req, return);
1054
1055         BT_INIT_PARAMS();
1056         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1057
1058         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
1059         g_array_append_vals(in_param2, req,  sizeof(bluetooth_mesh_network_group_info_t));
1060
1061         BT_INFO("Mesh: Remove Group Request");
1062         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_REMOVE_GROUP,
1063                         in_param1, in_param2, in_param3, in_param4, &out_param);
1064
1065         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1066
1067         return result;
1068 }
1069
1070 BT_EXPORT_API int bluetooth_mesh_network_create_group(
1071                 bluetooth_mesh_network_t *network, bool is_virtual,
1072                         uint16_t grp_addr, bluetooth_mesh_network_group_info_t *info)
1073 {
1074         int result;
1075
1076         BT_CHECK_PARAMETER(network, return);
1077         BT_CHECK_PARAMETER(info, return);
1078
1079         BT_INIT_PARAMS();
1080         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1081
1082         g_array_append_vals(in_param1, network,  sizeof(bluetooth_mesh_network_t));
1083         g_array_append_vals(in_param2, &is_virtual,  sizeof(gboolean));
1084         g_array_append_vals(in_param3, &grp_addr,  sizeof(guint16));
1085
1086         BT_INFO("Mesh: Create Group Request");
1087         result = _bt_send_request(BT_BLUEZ_SERVICE, BT_MESH_NETWORK_CREATE_GROUP,
1088                         in_param1, in_param2, in_param3, in_param4, &out_param);
1089
1090         if (result == BLUETOOTH_ERROR_NONE) {
1091                 *info = g_array_index(out_param,
1092                                 bluetooth_mesh_network_group_info_t, 0);
1093         }
1094         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1095
1096         return result;
1097 }
1098
1099 BT_EXPORT_API int bluetooth_mesh_model_configure_group_sub(
1100                         bluetooth_mesh_model_configure_t *req)
1101 {
1102         int result = 0;
1103         bt_user_info_t *user_info;
1104
1105         BT_CHECK_PARAMETER(req, return);
1106
1107         user_info = _bt_get_user_data(BT_MESH);
1108         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1109
1110         BT_INIT_PARAMS();
1111         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1112
1113         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1114
1115         BT_INFO("Mesh:Model Group Subscription Request");
1116         result = _bt_send_request_async(BT_BLUEZ_SERVICE, BT_MESH_MODEL_CONFIG_GROUP_SUB,
1117                         in_param1, in_param2, in_param3, in_param4,
1118                         user_info->cb, user_info->user_data);
1119
1120         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1121         return result;
1122 }
1123
1124 BT_EXPORT_API int bluetooth_mesh_model_configure_virtual_group_sub(
1125                         bluetooth_mesh_model_configure_t *req)
1126 {
1127         int result = 0;
1128         bt_user_info_t *user_info;
1129
1130         BT_CHECK_PARAMETER(req, return);
1131
1132         user_info = _bt_get_user_data(BT_MESH);
1133         retv_if(user_info->cb == NULL, BLUETOOTH_ERROR_INTERNAL);
1134
1135         BT_INIT_PARAMS();
1136         BT_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1137
1138         g_array_append_vals(in_param1, req,  sizeof(bluetooth_mesh_model_configure_t));
1139
1140         BT_INFO("Mesh: Model Virtual Group Subscription Request");
1141         result = _bt_send_request_async(BT_BLUEZ_SERVICE,
1142                         BT_MESH_MODEL_CONFIG_VIRTUAL_GROUP_SUB,
1143                         in_param1, in_param2, in_param3, in_param4,
1144                         user_info->cb, user_info->user_data);
1145
1146         BT_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1147         return result;
1148 }