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